stable diffusion og.

Author: sayakpaul

check_duplicate.py

@@ -0,0 +1,97 @@
+import ast
+import argparse
+from pathlib import Path
+from collections import defaultdict
+
+# This script requires Python 3.9+ for the ast.unparse() function.
+
+class ClassMethodVisitor(ast.NodeVisitor):
+    """
+    An AST visitor that collects method names and the source code of their bodies.
+    """
+    def __init__(self):
+        self.methods = defaultdict(list)
+
+    def visit_ClassDef(self, node: ast.ClassDef):
+        """
+        Visits a class definition, then inspects its methods.
+        """
+        class_name = node.name
+        for item in node.body:
+            if isinstance(item, ast.FunctionDef):
+                method_name = item.name
+                body_source = ast.unparse(item.body).strip()
+                self.methods[method_name].append((class_name, body_source))
+        self.generic_visit(node)
+
+def find_duplicate_method_content(directory: str, show_code: bool = True):
+    """
+    Parses all Python files in a directory to find methods with duplicate content.
+
+    Args:
+        directory: The path to the directory to inspect.
+        show_code: If True, prints the shared code block for each duplicate.
+    """
+    target_dir = Path(directory)
+    if not target_dir.is_dir():
+        print(f"❌ Error: '{directory}' is not a valid directory.")
+        return
+
+    visitor = ClassMethodVisitor()
+
+    for py_file in target_dir.rglob('*.py'):
+        try:
+            with open(py_file, 'r', encoding='utf-8') as f:
+                source_code = f.read()
+                tree = ast.parse(source_code, filename=py_file)
+                visitor.visit(tree)
+        except Exception as e:
+            print(f"⚠️ Warning: Could not process {py_file}. Error: {e}")
+
+    print("\n--- Duplicate Method Content Report ---")
+    duplicates_found = False
+
+    for method_name, implementations in sorted(visitor.methods.items()):
+        body_groups = defaultdict(list)
+        for class_name, body_source in implementations:
+            body_groups[body_source].append(class_name)
+
+        for body_source, class_list in body_groups.items():
+            if len(class_list) > 1:
+                duplicates_found = True
+                unique_classes = sorted(list(set(class_list)))
+                print(f"\n[+] Method `def {method_name}(...)` has identical content in {len(unique_classes)} classes:")
+                for class_name in unique_classes:
+                    print(f"  - {class_name}")
+
+                # Conditionally print the shared code block based on the flag
+                if show_code:
+                    print("\n  Shared Code Block:")
+                    indented_code = "\n".join([f"    {line}" for line in body_source.splitlines()])
+                    print(indented_code)
+                    print("  " + "-" * 30)
+
+    if not duplicates_found:
+        print("\n✅ No methods with identical content were found across classes.")
+
+def main():
+    """Main function to set up argument parsing."""
+    parser = argparse.ArgumentParser(
+        description="Find methods with identical content across Python classes in a directory."
+    )
+    parser.add_argument(
+        "directory",
+        type=str,
+        help="The path to the directory to inspect."
+    )
+    # New argument to control output verbosity
+    parser.add_argument(
+        "--hide-code",
+        action="store_true",
+        help="Do not print the shared code block for each duplicate found."
+    )
+    args = parser.parse_args()
+    find_duplicate_method_content(args.directory, show_code=not args.hide_code)
+
+if __name__ == "__main__":
+    main()

src/diffusers/pipelines/pipeline_utils.py

@@ -44,8 +44,6 @@
 
 from .. import __version__
 from ..configuration_utils import ConfigMixin
-from ..models import AutoencoderKL
-from ..models.attention_processor import FusedAttnProcessor2_0
 from ..models.modeling_utils import _LOW_CPU_MEM_USAGE_DEFAULT, ModelMixin
 from ..quantizers import PipelineQuantizationConfig
 from ..quantizers.bitsandbytes.utils import _check_bnb_status
@@ -69,6 +67,7 @@
 )
 from ..utils.hub_utils import _check_legacy_sharding_variant_format, load_or_create_model_card, populate_model_card
 from ..utils.torch_utils import empty_device_cache, get_device, is_compiled_module
+from .stable_diffusion.pipeline_stable_diffusion_utils import StableDiffusionMixin as ActualStableDiffusionMixin
 
 
 if is_torch_npu_available():
@@ -2172,137 +2171,8 @@ def _maybe_raise_error_if_group_offload_active(
         return False
 
 
-class StableDiffusionMixin:
-    r"""
-    Helper for DiffusionPipeline with vae and unet.(mainly for LDM such as stable diffusion)
-    """
-
-    def enable_vae_slicing(self):
-        r"""
-        Enable sliced VAE decoding. When this option is enabled, the VAE will split the input tensor in slices to
-        compute decoding in several steps. This is useful to save some memory and allow larger batch sizes.
-        """
-        depr_message = f"Calling `enable_vae_slicing()` on a `{self.__class__.__name__}` is deprecated and this method will be removed in a future version. Please use `pipe.vae.enable_slicing()`."
-        deprecate(
-            "enable_vae_slicing",
-            "0.40.0",
-            depr_message,
-        )
-        self.vae.enable_slicing()
-
-    def disable_vae_slicing(self):
-        r"""
-        Disable sliced VAE decoding. If `enable_vae_slicing` was previously enabled, this method will go back to
-        computing decoding in one step.
-        """
-        depr_message = f"Calling `disable_vae_slicing()` on a `{self.__class__.__name__}` is deprecated and this method will be removed in a future version. Please use `pipe.vae.disable_slicing()`."
-        deprecate(
-            "disable_vae_slicing",
-            "0.40.0",
-            depr_message,
-        )
-        self.vae.disable_slicing()
-
-    def enable_vae_tiling(self):
-        r"""
-        Enable tiled VAE decoding. When this option is enabled, the VAE will split the input tensor into tiles to
-        compute decoding and encoding in several steps. This is useful for saving a large amount of memory and to allow
-        processing larger images.
-        """
-        depr_message = f"Calling `enable_vae_tiling()` on a `{self.__class__.__name__}` is deprecated and this method will be removed in a future version. Please use `pipe.vae.enable_tiling()`."
-        deprecate(
-            "enable_vae_tiling",
-            "0.40.0",
-            depr_message,
-        )
-        self.vae.enable_tiling()
-
-    def disable_vae_tiling(self):
-        r"""
-        Disable tiled VAE decoding. If `enable_vae_tiling` was previously enabled, this method will go back to
-        computing decoding in one step.
-        """
-        depr_message = f"Calling `disable_vae_tiling()` on a `{self.__class__.__name__}` is deprecated and this method will be removed in a future version. Please use `pipe.vae.disable_tiling()`."
-        deprecate(
-            "disable_vae_tiling",
-            "0.40.0",
-            depr_message,
-        )
-        self.vae.disable_tiling()
-
-    def enable_freeu(self, s1: float, s2: float, b1: float, b2: float):
-        r"""Enables the FreeU mechanism as in https://huggingface.co/papers/2309.11497.
-
-        The suffixes after the scaling factors represent the stages where they are being applied.
-
-        Please refer to the [official repository](https://github.com/ChenyangSi/FreeU) for combinations of the values
-        that are known to work well for different pipelines such as Stable Diffusion v1, v2, and Stable Diffusion XL.
-
-        Args:
-            s1 (`float`):
-                Scaling factor for stage 1 to attenuate the contributions of the skip features. This is done to
-                mitigate "oversmoothing effect" in the enhanced denoising process.
-            s2 (`float`):
-                Scaling factor for stage 2 to attenuate the contributions of the skip features. This is done to
-                mitigate "oversmoothing effect" in the enhanced denoising process.
-            b1 (`float`): Scaling factor for stage 1 to amplify the contributions of backbone features.
-            b2 (`float`): Scaling factor for stage 2 to amplify the contributions of backbone features.
-        """
-        if not hasattr(self, "unet"):
-            raise ValueError("The pipeline must have `unet` for using FreeU.")
-        self.unet.enable_freeu(s1=s1, s2=s2, b1=b1, b2=b2)
-
-    def disable_freeu(self):
-        """Disables the FreeU mechanism if enabled."""
-        self.unet.disable_freeu()
-
-    def fuse_qkv_projections(self, unet: bool = True, vae: bool = True):
-        """
-        Enables fused QKV projections. For self-attention modules, all projection matrices (i.e., query, key, value)
-        are fused. For cross-attention modules, key and value projection matrices are fused.
-
-        > [!WARNING] > This API is 🧪 experimental.
-
-        Args:
-            unet (`bool`, defaults to `True`): To apply fusion on the UNet.
-            vae (`bool`, defaults to `True`): To apply fusion on the VAE.
-        """
-        self.fusing_unet = False
-        self.fusing_vae = False
-
-        if unet:
-            self.fusing_unet = True
-            self.unet.fuse_qkv_projections()
-            self.unet.set_attn_processor(FusedAttnProcessor2_0())
-
-        if vae:
-            if not isinstance(self.vae, AutoencoderKL):
-                raise ValueError("`fuse_qkv_projections()` is only supported for the VAE of type `AutoencoderKL`.")
-
-            self.fusing_vae = True
-            self.vae.fuse_qkv_projections()
-            self.vae.set_attn_processor(FusedAttnProcessor2_0())
-
-    def unfuse_qkv_projections(self, unet: bool = True, vae: bool = True):
-        """Disable QKV projection fusion if enabled.
-
-        > [!WARNING] > This API is 🧪 experimental.
-
-        Args:
-            unet (`bool`, defaults to `True`): To apply fusion on the UNet.
-            vae (`bool`, defaults to `True`): To apply fusion on the VAE.
-
-        """
-        if unet:
-            if not self.fusing_unet:
-                logger.warning("The UNet was not initially fused for QKV projections. Doing nothing.")
-            else:
-                self.unet.unfuse_qkv_projections()
-                self.fusing_unet = False
-
-        if vae:
-            if not self.fusing_vae:
-                logger.warning("The VAE was not initially fused for QKV projections. Doing nothing.")
-            else:
-                self.vae.unfuse_qkv_projections()
-                self.fusing_vae = False
+class StableDiffusionMixin(ActualStableDiffusionMixin):
+    def __init__(self, *args, **kwargs):
+        deprecation_message = "`StableDiffusionMixin` from `diffusers.pipelines.pipeline_utils` is deprecated and this will be removed in a future version. Please use `StableDiffusionMixin` from `diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_utils`, instead."
+        deprecate("StableDiffusionMixin", "1.0.0", deprecation_message)
+        super().__init__(*args, **kwargs)