CavinHuang-comfyui-nodes-docs/docs/Inference_Core_LayeredDiffusionDecodeSplit.md

Documentation

• Class name: Inference_Core_LayeredDiffusionDecodeSplit
• Category: layer_diffuse
• Output node: False
• Repo Ref: https://github.com/comfyanonymous/ComfyUI

这个节点专门用于通过分层扩散过程对图像进行解码，特别适用于处理分割图像数据。它利用修改后的扩散解码方法来分段处理图像，优化了将图像分为帧或层以提高推理性能的场景。

Input types

Required

• samples
  • 节点将处理的样本数据集合。这些数据对解码操作至关重要，因为它直接影响解码图像的分割、处理和最终质量。
  • Comfy dtype: LATENT
  • Python dtype: Dict[str, torch.Tensor]
• images
  • 待解码的图像张量。这个输入是节点功能的核心，因为它会根据提供的样本和帧直接操作这些图像。
  • Comfy dtype: IMAGE
  • Python dtype: torch.Tensor
• frames
  • 指定图像被划分的帧数或段数。这个参数对确定图像如何被处理和解码至关重要。
  • Comfy dtype: INT
  • Python dtype: int
• sd_version
  • 用于解码的Stable Diffusion模型版本。这会影响解码行为和输出图像的质量。
  • Comfy dtype: COMBO[STRING]
  • Python dtype: str
• sub_batch_size
  • 处理的子批次大小，允许在解码过程中优化资源利用。
  • Comfy dtype: INT
  • Python dtype: int

Output types

• image
  • 通过分层扩散方法处理的解码图像。这个输出对于理解解码过程的有效性和质量至关重要。
  • Comfy dtype: IMAGE
  • Python dtype: torch.Tensor

Usage tips

• Infra type: GPU
• Common nodes: unknown

Source code

class LayeredDiffusionDecodeSplit(LayeredDiffusionDecodeRGBA):
    """Decode RGBA every N images."""

    @classmethod
    def INPUT_TYPES(s):
        return {
            "required": {
                "samples": ("LATENT",),
                "images": ("IMAGE",),
                # Do RGBA decode every N output images.
                "frames": (
                    "INT",
                    {"default": 2, "min": 2, "max": s.MAX_FRAMES, "step": 1},
                ),
                "sd_version": (
                    [
                        StableDiffusionVersion.SD1x.value,
                        StableDiffusionVersion.SDXL.value,
                    ],
                    {
                        "default": StableDiffusionVersion.SDXL.value,
                    },
                ),
                "sub_batch_size": (
                    "INT",
                    {"default": 16, "min": 1, "max": 4096, "step": 1},
                ),
            },
        }

    MAX_FRAMES = 3
    RETURN_TYPES = ("IMAGE",) * MAX_FRAMES

    def decode(
        self,
        samples,
        images: torch.Tensor,
        frames: int,
        sd_version: str,
        sub_batch_size: int,
    ):
        sliced_samples = copy.copy(samples)
        sliced_samples["samples"] = sliced_samples["samples"][::frames]
        return tuple(
            (
                (
                    super(LayeredDiffusionDecodeSplit, self).decode(
                        sliced_samples, imgs, sd_version, sub_batch_size
                    )[0]
                    if i == 0
                    else imgs
                )
                for i in range(frames)
                for imgs in (images[i::frames],)
            )
        ) + (None,) * (self.MAX_FRAMES - frames)