cache-dit 0.2.11__py3-none-any.whl → 0.2.13__py3-none-any.whl

cache_dit/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.2.11'
-__version_tuple__ = version_tuple = (0, 2, 11)
+__version__ = version = '0.2.13'
+__version_tuple__ = version_tuple = (0, 2, 13)

cache_dit/metrics/lpips.py

@@ -0,0 +1,43 @@
+import builtins as __builtin__
+import contextlib
+import warnings
+
+import lpips
+import torch
+
+warnings.filterwarnings("ignore")
+
+lpips_loss_fn_vgg = None
+lpips_loss_fn_alex = None
+
+
+def dummy_print(*args, **kwargs):
+    pass
+
+
+@contextlib.contextmanager
+def disable_print():
+    origin_print = __builtin__.print
+    __builtin__.print = dummy_print
+    yield
+    __builtin__.print = origin_print
+
+
+def compute_lpips_img(img0, img1, net: str = "alex"):
+    global lpips_loss_fn_vgg
+    global lpips_loss_fn_alex
+    if net.lower() == "alex":
+        if lpips_loss_fn_alex is None:
+            with disable_print():
+                lpips_loss_fn_alex = lpips.LPIPS(net="alex")
+        loss_fn = lpips_loss_fn_alex
+    elif net.lower() == "vgg":
+        if lpips_loss_fn_vgg is None:
+            with disable_print():
+                lpips_loss_fn_vgg = lpips.LPIPS(net="vgg")
+        loss_fn = lpips_loss_fn_vgg
+    else:
+        assert False, f"unsupport net {net}"
+
+    with torch.no_grad():
+        return loss_fn(img0, img1).item()

cache_dit/metrics/metrics.py

@@ -14,6 +14,7 @@ from cache_dit.metrics.config import get_metrics_verbose
 from cache_dit.metrics.config import _IMAGE_EXTENSIONS
 from cache_dit.metrics.config import _VIDEO_EXTENSIONS
 from cache_dit.logger import init_logger
+from cache_dit.metrics.lpips import compute_lpips_img
 
 logger = init_logger(__name__)
 
@@ -21,6 +22,35 @@ logger = init_logger(__name__)
 DISABLE_VERBOSE = not get_metrics_verbose()
 
 
+def compute_lpips_file(
+    image_true: np.ndarray | str,
+    image_test: np.ndarray | str,
+) -> float:
+    import torch
+    from PIL import Image
+    from torchvision.transforms.v2.functional import (
+        convert_image_dtype,
+        normalize,
+        pil_to_tensor,
+    )
+
+    def load_img_as_tensor(path):
+        pil = Image.open(path)
+        img = pil_to_tensor(pil)
+        img = convert_image_dtype(img, dtype=torch.float32)
+        img = normalize(img, mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
+        return img
+
+    if isinstance(image_true, str):
+        image_true = load_img_as_tensor(image_true)
+    if isinstance(image_test, str):
+        image_test = load_img_as_tensor(image_test)
+    return compute_lpips_img(
+        image_true,
+        image_test,
+    )
+
+
 def compute_psnr_file(
     image_true: np.ndarray | str,
     image_test: np.ndarray | str,
@@ -305,6 +335,11 @@ def compute_video_metric(
         return None, None
 
 
+compute_lpips = partial(
+    compute_dir_metric,
+    compute_file_func=compute_lpips_file,
+)
+
 compute_psnr = partial(
     compute_dir_metric,
     compute_file_func=compute_psnr_file,
@@ -320,6 +355,10 @@ compute_mse = partial(
     compute_file_func=compute_mse_file,
 )
 
+compute_video_lpips = partial(
+    compute_video_metric,
+    compute_frame_func=compute_lpips_file,
+)
 compute_video_psnr = partial(
     compute_video_metric,
     compute_frame_func=compute_psnr_file,
@@ -335,6 +374,7 @@ compute_video_mse = partial(
 
 
 METRICS_CHOICES = [
+    "lpips",
     "psnr",
     "ssim",
     "mse",
@@ -439,11 +479,34 @@ def get_args():
 
     # Format output
     parser.add_argument(
-        "--sort-output",
-        "-sort",
+        "--summary",
+        "-s",
         action="store_true",
         default=False,
-        help="Sort the outupt metrics results",
+        help="Summary the outupt metrics results",
+    )
+
+    # Addtional perf log
+    parser.add_argument(
+        "--perf-log",
+        "-plog",
+        type=str,
+        default=None,
+        help="Path to addtional perf log",
+    )
+    parser.add_argument(
+        "--perf-tag",
+        "-ptag",
+        type=str,
+        default=None,
+        help="Tag to parse perf time from perf log",
+    )
+    parser.add_argument(
+        "--extra-perf-tags",
+        "-extra-ptags",
+        nargs="+",
+        default=[],
+        help="Extra tags to parse perf time from perf log",
     )
     return parser.parse_args()
 
@@ -489,28 +552,31 @@ def entrypoint():
             img_true_info = os.path.basename(img_true)
             img_test_info = os.path.basename(img_test)
 
-            def _logging_msg(value: float, n: int):
+            def _logging_msg(value: float, name, n: int):
                 if value is None or n is None:
                     return
                 msg = (
                     f"{img_true_info} vs {img_test_info}, "
-                    f"Num: {n}, {metric.upper()}: {value:.5f}"
+                    f"Num: {n}, {name.upper()}: {value:.5f}"
                 )
                 METRICS_META[msg] = value
                 logger.info(msg)
 
+            if metric == "lpips" or metric == "all":
+                img_lpips, n = compute_lpips(img_true, img_test)
+                _logging_msg(img_lpips, "lpips", n)
             if metric == "psnr" or metric == "all":
                 img_psnr, n = compute_psnr(img_true, img_test)
-                _logging_msg(img_psnr, n)
+                _logging_msg(img_psnr, "psnr", n)
             if metric == "ssim" or metric == "all":
                 img_ssim, n = compute_ssim(img_true, img_test)
-                _logging_msg(img_ssim, n)
+                _logging_msg(img_ssim, "ssim", n)
             if metric == "mse" or metric == "all":
                 img_mse, n = compute_mse(img_true, img_test)
-                _logging_msg(img_mse, n)
+                _logging_msg(img_mse, "mse", n)
             if metric == "fid" or metric == "all":
                 img_fid, n = FID.compute_fid(img_true, img_test)
-                _logging_msg(img_fid, n)
+                _logging_msg(img_fid, "fid", n)
 
         if video_true is not None and video_test is not None:
             if any(
@@ -525,28 +591,31 @@ def entrypoint():
             video_true_info = os.path.basename(video_true)
             video_test_info = os.path.basename(video_test)
 
-            def _logging_msg(value: float, n: int):
+            def _logging_msg(value: float, name, n: int):
                 if value is None or n is None:
                     return
                 msg = (
                     f"{video_true_info} vs {video_test_info}, "
-                    f"Frames: {n}, {metric.upper()}: {value:.5f}"
+                    f"Frames: {n}, {name.upper()}: {value:.5f}"
                 )
                 METRICS_META[msg] = value
                 logger.info(msg)
 
+            if metric == "lpips" or metric == "all":
+                video_lpips, n = compute_video_lpips(video_true, video_test)
+                _logging_msg(video_lpips, "lpips", n)
             if metric == "psnr" or metric == "all":
                 video_psnr, n = compute_video_psnr(video_true, video_test)
-                _logging_msg(video_psnr, n)
+                _logging_msg(video_psnr, "psnr", n)
             if metric == "ssim" or metric == "all":
                 video_ssim, n = compute_video_ssim(video_true, video_test)
-                _logging_msg(video_ssim, n)
+                _logging_msg(video_ssim, "ssim", n)
             if metric == "mse" or metric == "all":
                 video_mse, n = compute_video_mse(video_true, video_test)
-                _logging_msg(video_mse, n)
+                _logging_msg(video_mse, "mse", n)
             if metric == "fid" or metric == "all":
                 video_fid, n = FID.compute_video_fid(video_true, video_test)
-                _logging_msg(video_fid, n)
+                _logging_msg(video_fid, "fid", n)
 
     # run selected metrics
     if not DISABLE_VERBOSE:
@@ -652,16 +721,44 @@ def entrypoint():
                 video_test=args.video_test,
             )
 
-    if args.sort_output:
+    if args.summary:
+
+        def _fetch_perf():
+            if args.perf_log is None or args.perf_tag is None:
+                return []
+            if not os.path.exists(args.perf_log):
+                return []
+            perf_texts = []
+            with open(args.perf_log, "r") as file:
+                perf_lines = file.readlines()
+                for line in perf_lines:
+                    line = line.strip()
+                    if args.perf_tag.lower() in line.lower():
+                        if len(args.extra_perf_tags) == 0:
+                            perf_texts.append(line)
+                        else:
+                            has_all_extra_tag = True
+                            for ext_tag in args.extra_perf_tags:
+                                if ext_tag.lower() not in line.lower():
+                                    has_all_extra_tag = False
+                                    break
+                            if has_all_extra_tag:
+                                perf_texts.append(line)
+            return perf_texts
+
+        PERF_TEXTS: list[str] = _fetch_perf()
 
         def _parse_value(
             text: str,
             tag: str = "Num",
-        ) -> float:
+        ) -> float | None:
             import re
 
+            escaped_tag = re.escape(tag)
+            processed_tag = escaped_tag.replace(r"\ ", r"\s+")
+
             pattern = re.compile(
-                rf"{re.escape(tag)}:\s*(\d+\.?\d*)", re.IGNORECASE
+                rf"{processed_tag}:\s*(\d+\.?\d*)\D*", re.IGNORECASE
             )
 
             match = pattern.search(text)
@@ -669,9 +766,30 @@ def entrypoint():
             if not match:
                 return None
 
-            if tag.lower() in METRICS_CHOICES:
-                return float(match.group(1))
-            return int(match.group(1))
+            value_str = match.group(1)
+            try:
+                if tag.lower() in METRICS_CHOICES:
+                    return float(value_str)
+                if args.perf_tag is not None:
+                    if tag.lower() == args.perf_tag.lower():
+                        return float(value_str)
+                return int(value_str)
+            except ValueError:
+                return None
+
+        def _parse_perf(
+            compare_tag: str,
+        ) -> float | None:
+            nonlocal PERF_TEXTS
+            perf_times = []
+            for line in PERF_TEXTS:
+                if compare_tag in line:
+                    perf_time = _parse_value(line, args.perf_tag)
+                    if perf_time is not None:
+                        perf_times.append(perf_time)
+            if len(perf_times) == 0:
+                return None
+            return sum(perf_times) / len(perf_times)
 
         def _format_item(
             key: str,
@@ -679,23 +797,52 @@ def entrypoint():
             value: float,
             max_key_len: int,
         ):
+            nonlocal PERF_TEXTS
             # U1-Q0-C0-NONE vs U4-Q1-C1-NONE
             header = key.split(",")[0].strip()
+            compare_tag = header.split("vs")[1].strip()  # U4-Q1-C1-NONE
+            has_perf_texts = len(PERF_TEXTS) > 0
+            format_str = ""
             # Num / Frames
             if n := _parse_value(key, "Num"):
-                print(
-                    f"{header:<{max_key_len}}  Num: {n}  "
-                    f"{metric.upper()}: {value:<.4f}"
-                )
+                if not has_perf_texts:
+                    format_str = (
+                        f"{header:<{max_key_len}}  Num: {n}  "
+                        f"{metric.upper()}: {value:<7.4f}"
+                    )
+                else:
+                    perf_time = _parse_perf(compare_tag)
+                    perf_time = f"{perf_time:<.2f}" if perf_time else None
+                    format_str = (
+                        f"{header:<{max_key_len}}  Num: {n}  "
+                        f"{metric.upper()}: {value:<7.4f}  "
+                        f"Perf: {perf_time}"
+                    )
             elif n := _parse_value(key, "Frames"):
-                print(
-                    f"{header:<{max_key_len}}  Frames: {n}  "
-                    f"{metric.upper()}: {value:<.4f}"
-                )
+                if not has_perf_texts:
+                    format_str = (
+                        f"{header:<{max_key_len}}  Frames: {n}  "
+                        f"{metric.upper()}: {value:<7.4f}"
+                    )
+                else:
+                    perf_time = _parse_perf(compare_tag)
+                    perf_time = f"{perf_time:<.2f}" if perf_time else None
+                    format_str = (
+                        f"{header:<{max_key_len}}  Frames: {n}  "
+                        f"{metric.upper()}: {value:<7.4f}  "
+                        f"Perf: {perf_time}"
+                    )
             else:
                 raise ValueError("Num or Frames can not be NoneType.")
 
-        for metric in args.metrics:
+            return format_str
+
+        selected_metrics = args.metrics
+        if "all" in selected_metrics:
+            selected_metrics = METRICS_CHOICES.copy()
+            selected_metrics.remove("all")
+
+        for metric in selected_metrics:
             selected_items = {}
             for key in METRICS_META.keys():
                 if metric.upper() in key or metric.lower() in key:
@@ -710,7 +857,14 @@ def entrypoint():
             ]
             max_key_len = max(len(key) for key in selected_keys)
 
-            format_len = int(max_key_len * 1.5)
+            format_strs = []
+            for key, value in sorted_items:
+                format_strs.append(
+                    _format_item(key, metric, value, max_key_len)
+                )
+
+            format_len = max(len(format_str) for format_str in format_strs)
+
             res_len = format_len - len(f"Summary: {metric.upper()}")
             left_len = res_len // 2
             right_len = res_len - left_len
@@ -719,8 +873,8 @@ def entrypoint():
                 " " * left_len + f"Summary: {metric.upper()}" + " " * right_len
             )
             print("-" * format_len)
-            for key, value in sorted_items:
-                _format_item(key, metric, value, max_key_len)
+            for format_str in format_strs:
+                print(format_str)
             print("-" * format_len)
 
 

{cache_dit-0.2.11.dist-info → cache_dit-0.2.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cache_dit
-Version: 0.2.11
+Version: 0.2.13
 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
@@ -16,6 +16,7 @@ Requires-Dist: transformers>=4.51.3
 Requires-Dist: diffusers>=0.33.1
 Requires-Dist: scikit-image
 Requires-Dist: scipy
+Requires-Dist: lpips==0.1.4
 Provides-Extra: all
 Provides-Extra: dev
 Requires-Dist: pre-commit; extra == "dev"
@@ -63,7 +64,7 @@ Dynamic: requires-python
 </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)**, please check [PR](https://github.com/huggingface/flux-fast/pull/13). 
+- [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.
 
 ## 🤗 Introduction 

{cache_dit-0.2.11.dist-info → cache_dit-0.2.13.dist-info}/RECORD

@@ -1,5 +1,5 @@
 cache_dit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cache_dit/_version.py,sha256=Y72g1mojWf0yRnnMW5zEUr6skXUSsqAdPjRJUrxXSYc,513
+cache_dit/_version.py,sha256=2ECxD0Bipdh9vxnyteM0k9jxi9NOpPR7YxTi7Ad1ors,513
 cache_dit/logger.py,sha256=0zsu42hN-3-rgGC_C29ms1IvVpV4_b4_SwJCKSenxBE,4304
 cache_dit/primitives.py,sha256=A2iG9YLot3gOsZSPp-_gyjqjLgJvWQRx8aitD4JQ23Y,3877
 cache_dit/cache_factory/__init__.py,sha256=iYQwLwB_XLoYl0OB9unZGDbBtrYvZaLkOAmhGRwdW2E,191
@@ -38,10 +38,11 @@ cache_dit/metrics/__init__.py,sha256=RaUhl5dieF40RqnizGzR30qoJJ9dyMUEADwgwMaMQrE
 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/metrics.py,sha256=PAzyhJawos1UeMnHsxcu4edkwCSYMBmjDGRR_--I104,22410
-cache_dit-0.2.11.dist-info/licenses/LICENSE,sha256=Dqb07Ik2dV41s9nIdMUbiRWEfDqo7-dQeRiY7kPO8PE,3769
-cache_dit-0.2.11.dist-info/METADATA,sha256=HExb-ldgaYzZRSCy6Tg6syONjd0uDoB8_8AShvbfA-0,28213
-cache_dit-0.2.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-cache_dit-0.2.11.dist-info/entry_points.txt,sha256=FX2gysXaZx6NeK1iCLMcIdP8Q4_qikkIHtEmi3oWn8o,65
-cache_dit-0.2.11.dist-info/top_level.txt,sha256=ZJDydonLEhujzz0FOkVbO-BqfzO9d_VqRHmZU-3MOZo,10
-cache_dit-0.2.11.dist-info/RECORD,,
+cache_dit/metrics/lpips.py,sha256=I2qCNi6qJh5TRsaIsdxO0WoRX1DN7U_H3zS0oCSahYM,1032
+cache_dit/metrics/metrics.py,sha256=8jvM1sF-nDxUuwCRy44QEoo4dYVLCQVh1QyAMs4eaQY,27840
+cache_dit-0.2.13.dist-info/licenses/LICENSE,sha256=Dqb07Ik2dV41s9nIdMUbiRWEfDqo7-dQeRiY7kPO8PE,3769
+cache_dit-0.2.13.dist-info/METADATA,sha256=at8DNFeGI5aVnBTi7_6zJgAi_QdgsItpBMzSGl8HEME,28247
+cache_dit-0.2.13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+cache_dit-0.2.13.dist-info/entry_points.txt,sha256=FX2gysXaZx6NeK1iCLMcIdP8Q4_qikkIHtEmi3oWn8o,65
+cache_dit-0.2.13.dist-info/top_level.txt,sha256=ZJDydonLEhujzz0FOkVbO-BqfzO9d_VqRHmZU-3MOZo,10
+cache_dit-0.2.13.dist-info/RECORD,,