Guard against zero std_cfg in rescale_noise_cfg (#13425)

src/diffusers/pipelines/animatediff/pipeline_animatediff_sdxl.py

@@ -141,6 +141,11 @@ def rescale_noise_cfg(noise_cfg, noise_pred_text, guidance_rescale=0.0):
     std_text = noise_pred_text.std(dim=list(range(1, noise_pred_text.ndim)), keepdim=True)
     std_cfg = noise_cfg.std(dim=list(range(1, noise_cfg.ndim)), keepdim=True)
     # rescale the results from guidance (fixes overexposure)
+    # Guard against `std_cfg == 0` (constant/zero `noise_cfg`, which can happen at the
+    # beginning of a schedule or in numerical edge cases): a raw division would produce
+    # `nan`/`inf` and silently corrupt the diffusion output (issue #13425). When the
+    # standard deviation of the guided prediction is zero, the rescaling is a no-op.
+    std_cfg = std_cfg.clamp(min=torch.finfo(noise_cfg.dtype).eps)
     noise_pred_rescaled = noise_cfg * (std_text / std_cfg)
     # mix with the original results from guidance by factor guidance_rescale to avoid "plain looking" images
     noise_cfg = guidance_rescale * noise_pred_rescaled + (1 - guidance_rescale) * noise_cfg

src/diffusers/pipelines/controlnet/pipeline_controlnet_inpaint_sd_xl.py

@@ -161,6 +161,11 @@ def rescale_noise_cfg(noise_cfg, noise_pred_text, guidance_rescale=0.0):
     std_text = noise_pred_text.std(dim=list(range(1, noise_pred_text.ndim)), keepdim=True)
     std_cfg = noise_cfg.std(dim=list(range(1, noise_cfg.ndim)), keepdim=True)
     # rescale the results from guidance (fixes overexposure)
+    # Guard against `std_cfg == 0` (constant/zero `noise_cfg`, which can happen at the
+    # beginning of a schedule or in numerical edge cases): a raw division would produce
+    # `nan`/`inf` and silently corrupt the diffusion output (issue #13425). When the
+    # standard deviation of the guided prediction is zero, the rescaling is a no-op.
+    std_cfg = std_cfg.clamp(min=torch.finfo(noise_cfg.dtype).eps)
     noise_pred_rescaled = noise_cfg * (std_text / std_cfg)
     # mix with the original results from guidance by factor guidance_rescale to avoid "plain looking" images
     noise_cfg = guidance_rescale * noise_pred_rescaled + (1 - guidance_rescale) * noise_cfg

src/diffusers/pipelines/controlnet/pipeline_controlnet_union_inpaint_sd_xl.py

@@ -151,6 +151,11 @@ def rescale_noise_cfg(noise_cfg, noise_pred_text, guidance_rescale=0.0):
     std_text = noise_pred_text.std(dim=list(range(1, noise_pred_text.ndim)), keepdim=True)
     std_cfg = noise_cfg.std(dim=list(range(1, noise_cfg.ndim)), keepdim=True)
     # rescale the results from guidance (fixes overexposure)
+    # Guard against `std_cfg == 0` (constant/zero `noise_cfg`, which can happen at the
+    # beginning of a schedule or in numerical edge cases): a raw division would produce
+    # `nan`/`inf` and silently corrupt the diffusion output (issue #13425). When the
+    # standard deviation of the guided prediction is zero, the rescaling is a no-op.
+    std_cfg = std_cfg.clamp(min=torch.finfo(noise_cfg.dtype).eps)
     noise_pred_rescaled = noise_cfg * (std_text / std_cfg)
     # mix with the original results from guidance by factor guidance_rescale to avoid "plain looking" images
     noise_cfg = guidance_rescale * noise_pred_rescaled + (1 - guidance_rescale) * noise_cfg

src/diffusers/pipelines/controlnet_hunyuandit/pipeline_hunyuandit_controlnet.py

@@ -156,6 +156,11 @@ def rescale_noise_cfg(noise_cfg, noise_pred_text, guidance_rescale=0.0):
     std_text = noise_pred_text.std(dim=list(range(1, noise_pred_text.ndim)), keepdim=True)
     std_cfg = noise_cfg.std(dim=list(range(1, noise_cfg.ndim)), keepdim=True)
     # rescale the results from guidance (fixes overexposure)
+    # Guard against `std_cfg == 0` (constant/zero `noise_cfg`, which can happen at the
+    # beginning of a schedule or in numerical edge cases): a raw division would produce
+    # `nan`/`inf` and silently corrupt the diffusion output (issue #13425). When the
+    # standard deviation of the guided prediction is zero, the rescaling is a no-op.
+    std_cfg = std_cfg.clamp(min=torch.finfo(noise_cfg.dtype).eps)
     noise_pred_rescaled = noise_cfg * (std_text / std_cfg)
     # mix with the original results from guidance by factor guidance_rescale to avoid "plain looking" images
     noise_cfg = guidance_rescale * noise_pred_rescaled + (1 - guidance_rescale) * noise_cfg

src/diffusers/pipelines/deprecated/alt_diffusion/pipeline_alt_diffusion.py

@@ -84,6 +84,11 @@ def rescale_noise_cfg(noise_cfg, noise_pred_text, guidance_rescale=0.0):
     std_text = noise_pred_text.std(dim=list(range(1, noise_pred_text.ndim)), keepdim=True)
     std_cfg = noise_cfg.std(dim=list(range(1, noise_cfg.ndim)), keepdim=True)
     # rescale the results from guidance (fixes overexposure)
+    # Guard against `std_cfg == 0` (constant/zero `noise_cfg`, which can happen at the
+    # beginning of a schedule or in numerical edge cases): a raw division would produce
+    # `nan`/`inf` and silently corrupt the diffusion output (issue #13425). When the
+    # standard deviation of the guided prediction is zero, the rescaling is a no-op.
+    std_cfg = std_cfg.clamp(min=torch.finfo(noise_cfg.dtype).eps)
     noise_pred_rescaled = noise_cfg * (std_text / std_cfg)
     # mix with the original results from guidance by factor guidance_rescale to avoid "plain looking" images
     noise_cfg = guidance_rescale * noise_pred_rescaled + (1 - guidance_rescale) * noise_cfg

src/diffusers/pipelines/deprecated/stable_diffusion_ldm3d/pipeline_stable_diffusion_ldm3d.py

@@ -94,6 +94,11 @@ def rescale_noise_cfg(noise_cfg, noise_pred_text, guidance_rescale=0.0):
     std_text = noise_pred_text.std(dim=list(range(1, noise_pred_text.ndim)), keepdim=True)
     std_cfg = noise_cfg.std(dim=list(range(1, noise_cfg.ndim)), keepdim=True)
     # rescale the results from guidance (fixes overexposure)
+    # Guard against `std_cfg == 0` (constant/zero `noise_cfg`, which can happen at the
+    # beginning of a schedule or in numerical edge cases): a raw division would produce
+    # `nan`/`inf` and silently corrupt the diffusion output (issue #13425). When the
+    # standard deviation of the guided prediction is zero, the rescaling is a no-op.
+    std_cfg = std_cfg.clamp(min=torch.finfo(noise_cfg.dtype).eps)
     noise_pred_rescaled = noise_cfg * (std_text / std_cfg)
     # mix with the original results from guidance by factor guidance_rescale to avoid "plain looking" images
     noise_cfg = guidance_rescale * noise_pred_rescaled + (1 - guidance_rescale) * noise_cfg

src/diffusers/pipelines/deprecated/stable_diffusion_panorama/pipeline_stable_diffusion_panorama.py

@@ -89,6 +89,11 @@ def rescale_noise_cfg(noise_cfg, noise_pred_text, guidance_rescale=0.0):
     std_text = noise_pred_text.std(dim=list(range(1, noise_pred_text.ndim)), keepdim=True)
     std_cfg = noise_cfg.std(dim=list(range(1, noise_cfg.ndim)), keepdim=True)
     # rescale the results from guidance (fixes overexposure)
+    # Guard against `std_cfg == 0` (constant/zero `noise_cfg`, which can happen at the
+    # beginning of a schedule or in numerical edge cases): a raw division would produce
+    # `nan`/`inf` and silently corrupt the diffusion output (issue #13425). When the
+    # standard deviation of the guided prediction is zero, the rescaling is a no-op.
+    std_cfg = std_cfg.clamp(min=torch.finfo(noise_cfg.dtype).eps)
     noise_pred_rescaled = noise_cfg * (std_text / std_cfg)
     # mix with the original results from guidance by factor guidance_rescale to avoid "plain looking" images
     noise_cfg = guidance_rescale * noise_pred_rescaled + (1 - guidance_rescale) * noise_cfg

src/diffusers/pipelines/deprecated/text_to_video_synthesis/pipeline_text_to_video_zero_sdxl.py

@@ -335,6 +335,11 @@ def rescale_noise_cfg(noise_cfg, noise_pred_text, guidance_rescale=0.0):
     std_text = noise_pred_text.std(dim=list(range(1, noise_pred_text.ndim)), keepdim=True)
     std_cfg = noise_cfg.std(dim=list(range(1, noise_cfg.ndim)), keepdim=True)
     # rescale the results from guidance (fixes overexposure)
+    # Guard against `std_cfg == 0` (constant/zero `noise_cfg`, which can happen at the
+    # beginning of a schedule or in numerical edge cases): a raw division would produce
+    # `nan`/`inf` and silently corrupt the diffusion output (issue #13425). When the
+    # standard deviation of the guided prediction is zero, the rescaling is a no-op.
+    std_cfg = std_cfg.clamp(min=torch.finfo(noise_cfg.dtype).eps)
     noise_pred_rescaled = noise_cfg * (std_text / std_cfg)
     # mix with the original results from guidance by factor guidance_rescale to avoid "plain looking" images
     noise_cfg = guidance_rescale * noise_pred_rescaled + (1 - guidance_rescale) * noise_cfg

src/diffusers/pipelines/easyanimate/pipeline_easyanimate.py

@@ -117,6 +117,11 @@ def rescale_noise_cfg(noise_cfg, noise_pred_text, guidance_rescale=0.0):
     std_text = noise_pred_text.std(dim=list(range(1, noise_pred_text.ndim)), keepdim=True)
     std_cfg = noise_cfg.std(dim=list(range(1, noise_cfg.ndim)), keepdim=True)
     # rescale the results from guidance (fixes overexposure)
+    # Guard against `std_cfg == 0` (constant/zero `noise_cfg`, which can happen at the
+    # beginning of a schedule or in numerical edge cases): a raw division would produce
+    # `nan`/`inf` and silently corrupt the diffusion output (issue #13425). When the
+    # standard deviation of the guided prediction is zero, the rescaling is a no-op.
+    std_cfg = std_cfg.clamp(min=torch.finfo(noise_cfg.dtype).eps)
     noise_pred_rescaled = noise_cfg * (std_text / std_cfg)
     # mix with the original results from guidance by factor guidance_rescale to avoid "plain looking" images
     noise_cfg = guidance_rescale * noise_pred_rescaled + (1 - guidance_rescale) * noise_cfg

src/diffusers/pipelines/easyanimate/pipeline_easyanimate_control.py

@@ -193,6 +193,11 @@ def rescale_noise_cfg(noise_cfg, noise_pred_text, guidance_rescale=0.0):
     std_text = noise_pred_text.std(dim=list(range(1, noise_pred_text.ndim)), keepdim=True)
     std_cfg = noise_cfg.std(dim=list(range(1, noise_cfg.ndim)), keepdim=True)
     # rescale the results from guidance (fixes overexposure)
+    # Guard against `std_cfg == 0` (constant/zero `noise_cfg`, which can happen at the
+    # beginning of a schedule or in numerical edge cases): a raw division would produce
+    # `nan`/`inf` and silently corrupt the diffusion output (issue #13425). When the
+    # standard deviation of the guided prediction is zero, the rescaling is a no-op.
+    std_cfg = std_cfg.clamp(min=torch.finfo(noise_cfg.dtype).eps)
     noise_pred_rescaled = noise_cfg * (std_text / std_cfg)
     # mix with the original results from guidance by factor guidance_rescale to avoid "plain looking" images
     noise_cfg = guidance_rescale * noise_pred_rescaled + (1 - guidance_rescale) * noise_cfg

src/diffusers/pipelines/easyanimate/pipeline_easyanimate_inpaint.py

@@ -215,6 +215,11 @@ def rescale_noise_cfg(noise_cfg, noise_pred_text, guidance_rescale=0.0):
     std_text = noise_pred_text.std(dim=list(range(1, noise_pred_text.ndim)), keepdim=True)
     std_cfg = noise_cfg.std(dim=list(range(1, noise_cfg.ndim)), keepdim=True)
     # rescale the results from guidance (fixes overexposure)
+    # Guard against `std_cfg == 0` (constant/zero `noise_cfg`, which can happen at the
+    # beginning of a schedule or in numerical edge cases): a raw division would produce
+    # `nan`/`inf` and silently corrupt the diffusion output (issue #13425). When the
+    # standard deviation of the guided prediction is zero, the rescaling is a no-op.
+    std_cfg = std_cfg.clamp(min=torch.finfo(noise_cfg.dtype).eps)
     noise_pred_rescaled = noise_cfg * (std_text / std_cfg)
     # mix with the original results from guidance by factor guidance_rescale to avoid "plain looking" images
     noise_cfg = guidance_rescale * noise_pred_rescaled + (1 - guidance_rescale) * noise_cfg

src/diffusers/pipelines/hunyuandit/pipeline_hunyuandit.py

@@ -140,6 +140,11 @@ def rescale_noise_cfg(noise_cfg, noise_pred_text, guidance_rescale=0.0):
     std_text = noise_pred_text.std(dim=list(range(1, noise_pred_text.ndim)), keepdim=True)
     std_cfg = noise_cfg.std(dim=list(range(1, noise_cfg.ndim)), keepdim=True)
     # rescale the results from guidance (fixes overexposure)
+    # Guard against `std_cfg == 0` (constant/zero `noise_cfg`, which can happen at the
+    # beginning of a schedule or in numerical edge cases): a raw division would produce
+    # `nan`/`inf` and silently corrupt the diffusion output (issue #13425). When the
+    # standard deviation of the guided prediction is zero, the rescaling is a no-op.
+    std_cfg = std_cfg.clamp(min=torch.finfo(noise_cfg.dtype).eps)
     noise_pred_rescaled = noise_cfg * (std_text / std_cfg)
     # mix with the original results from guidance by factor guidance_rescale to avoid "plain looking" images
     noise_cfg = guidance_rescale * noise_pred_rescaled + (1 - guidance_rescale) * noise_cfg

src/diffusers/pipelines/ledits_pp/pipeline_leditspp_stable_diffusion.py

@@ -260,6 +260,11 @@ def rescale_noise_cfg(noise_cfg, noise_pred_text, guidance_rescale=0.0):
     std_text = noise_pred_text.std(dim=list(range(1, noise_pred_text.ndim)), keepdim=True)
     std_cfg = noise_cfg.std(dim=list(range(1, noise_cfg.ndim)), keepdim=True)
     # rescale the results from guidance (fixes overexposure)
+    # Guard against `std_cfg == 0` (constant/zero `noise_cfg`, which can happen at the
+    # beginning of a schedule or in numerical edge cases): a raw division would produce
+    # `nan`/`inf` and silently corrupt the diffusion output (issue #13425). When the
+    # standard deviation of the guided prediction is zero, the rescaling is a no-op.
+    std_cfg = std_cfg.clamp(min=torch.finfo(noise_cfg.dtype).eps)
     noise_pred_rescaled = noise_cfg * (std_text / std_cfg)
     # mix with the original results from guidance by factor guidance_rescale to avoid "plain looking" images
     noise_cfg = guidance_rescale * noise_pred_rescaled + (1 - guidance_rescale) * noise_cfg

src/diffusers/pipelines/ledits_pp/pipeline_leditspp_stable_diffusion_xl.py

@@ -1722,6 +1722,11 @@ def rescale_noise_cfg(noise_cfg, noise_pred_text, guidance_rescale=0.0):
     std_text = noise_pred_text.std(dim=list(range(1, noise_pred_text.ndim)), keepdim=True)
     std_cfg = noise_cfg.std(dim=list(range(1, noise_cfg.ndim)), keepdim=True)
     # rescale the results from guidance (fixes overexposure)
+    # Guard against `std_cfg == 0` (constant/zero `noise_cfg`, which can happen at the
+    # beginning of a schedule or in numerical edge cases): a raw division would produce
+    # `nan`/`inf` and silently corrupt the diffusion output (issue #13425). When the
+    # standard deviation of the guided prediction is zero, the rescaling is a no-op.
+    std_cfg = std_cfg.clamp(min=torch.finfo(noise_cfg.dtype).eps)
     noise_pred_rescaled = noise_cfg * (std_text / std_cfg)
     # mix with the original results from guidance by factor guidance_rescale to avoid "plain looking" images
     noise_cfg = guidance_rescale * noise_pred_rescaled + (1 - guidance_rescale) * noise_cfg

src/diffusers/pipelines/ltx/pipeline_ltx.py

@@ -161,6 +161,11 @@ def rescale_noise_cfg(noise_cfg, noise_pred_text, guidance_rescale=0.0):
     std_text = noise_pred_text.std(dim=list(range(1, noise_pred_text.ndim)), keepdim=True)
     std_cfg = noise_cfg.std(dim=list(range(1, noise_cfg.ndim)), keepdim=True)
     # rescale the results from guidance (fixes overexposure)
+    # Guard against `std_cfg == 0` (constant/zero `noise_cfg`, which can happen at the
+    # beginning of a schedule or in numerical edge cases): a raw division would produce
+    # `nan`/`inf` and silently corrupt the diffusion output (issue #13425). When the
+    # standard deviation of the guided prediction is zero, the rescaling is a no-op.
+    std_cfg = std_cfg.clamp(min=torch.finfo(noise_cfg.dtype).eps)
     noise_pred_rescaled = noise_cfg * (std_text / std_cfg)
     # mix with the original results from guidance by factor guidance_rescale to avoid "plain looking" images
     noise_cfg = guidance_rescale * noise_pred_rescaled + (1 - guidance_rescale) * noise_cfg

src/diffusers/pipelines/ltx/pipeline_ltx_condition.py

@@ -243,6 +243,11 @@ def rescale_noise_cfg(noise_cfg, noise_pred_text, guidance_rescale=0.0):
     std_text = noise_pred_text.std(dim=list(range(1, noise_pred_text.ndim)), keepdim=True)
     std_cfg = noise_cfg.std(dim=list(range(1, noise_cfg.ndim)), keepdim=True)
     # rescale the results from guidance (fixes overexposure)
+    # Guard against `std_cfg == 0` (constant/zero `noise_cfg`, which can happen at the
+    # beginning of a schedule or in numerical edge cases): a raw division would produce
+    # `nan`/`inf` and silently corrupt the diffusion output (issue #13425). When the
+    # standard deviation of the guided prediction is zero, the rescaling is a no-op.
+    std_cfg = std_cfg.clamp(min=torch.finfo(noise_cfg.dtype).eps)
     noise_pred_rescaled = noise_cfg * (std_text / std_cfg)
     # mix with the original results from guidance by factor guidance_rescale to avoid "plain looking" images
     noise_cfg = guidance_rescale * noise_pred_rescaled + (1 - guidance_rescale) * noise_cfg

src/diffusers/pipelines/ltx/pipeline_ltx_i2v_long_multi_prompt.py

@@ -136,6 +136,11 @@ def rescale_noise_cfg(noise_cfg, noise_pred_text, guidance_rescale=0.0):
     std_text = noise_pred_text.std(dim=list(range(1, noise_pred_text.ndim)), keepdim=True)
     std_cfg = noise_cfg.std(dim=list(range(1, noise_cfg.ndim)), keepdim=True)
     # rescale the results from guidance (fixes overexposure)
+    # Guard against `std_cfg == 0` (constant/zero `noise_cfg`, which can happen at the
+    # beginning of a schedule or in numerical edge cases): a raw division would produce
+    # `nan`/`inf` and silently corrupt the diffusion output (issue #13425). When the
+    # standard deviation of the guided prediction is zero, the rescaling is a no-op.
+    std_cfg = std_cfg.clamp(min=torch.finfo(noise_cfg.dtype).eps)
     noise_pred_rescaled = noise_cfg * (std_text / std_cfg)
     # mix with the original results from guidance by factor guidance_rescale to avoid "plain looking" images
     noise_cfg = guidance_rescale * noise_pred_rescaled + (1 - guidance_rescale) * noise_cfg

src/diffusers/pipelines/ltx/pipeline_ltx_image2video.py

@@ -180,6 +180,11 @@ def rescale_noise_cfg(noise_cfg, noise_pred_text, guidance_rescale=0.0):
     std_text = noise_pred_text.std(dim=list(range(1, noise_pred_text.ndim)), keepdim=True)
     std_cfg = noise_cfg.std(dim=list(range(1, noise_cfg.ndim)), keepdim=True)
     # rescale the results from guidance (fixes overexposure)
+    # Guard against `std_cfg == 0` (constant/zero `noise_cfg`, which can happen at the
+    # beginning of a schedule or in numerical edge cases): a raw division would produce
+    # `nan`/`inf` and silently corrupt the diffusion output (issue #13425). When the
+    # standard deviation of the guided prediction is zero, the rescaling is a no-op.
+    std_cfg = std_cfg.clamp(min=torch.finfo(noise_cfg.dtype).eps)
     noise_pred_rescaled = noise_cfg * (std_text / std_cfg)
     # mix with the original results from guidance by factor guidance_rescale to avoid "plain looking" images
     noise_cfg = guidance_rescale * noise_pred_rescaled + (1 - guidance_rescale) * noise_cfg

src/diffusers/pipelines/ltx2/pipeline_ltx2.py

@@ -176,6 +176,11 @@ def rescale_noise_cfg(noise_cfg, noise_pred_text, guidance_rescale=0.0):
     std_text = noise_pred_text.std(dim=list(range(1, noise_pred_text.ndim)), keepdim=True)
     std_cfg = noise_cfg.std(dim=list(range(1, noise_cfg.ndim)), keepdim=True)
     # rescale the results from guidance (fixes overexposure)
+    # Guard against `std_cfg == 0` (constant/zero `noise_cfg`, which can happen at the
+    # beginning of a schedule or in numerical edge cases): a raw division would produce
+    # `nan`/`inf` and silently corrupt the diffusion output (issue #13425). When the
+    # standard deviation of the guided prediction is zero, the rescaling is a no-op.
+    std_cfg = std_cfg.clamp(min=torch.finfo(noise_cfg.dtype).eps)
     noise_pred_rescaled = noise_cfg * (std_text / std_cfg)
     # mix with the original results from guidance by factor guidance_rescale to avoid "plain looking" images
     noise_cfg = guidance_rescale * noise_pred_rescaled + (1 - guidance_rescale) * noise_cfg

src/diffusers/pipelines/ltx2/pipeline_ltx2_condition.py

@@ -226,6 +226,11 @@ def rescale_noise_cfg(noise_cfg, noise_pred_text, guidance_rescale=0.0):
     std_text = noise_pred_text.std(dim=list(range(1, noise_pred_text.ndim)), keepdim=True)
     std_cfg = noise_cfg.std(dim=list(range(1, noise_cfg.ndim)), keepdim=True)
     # rescale the results from guidance (fixes overexposure)
+    # Guard against `std_cfg == 0` (constant/zero `noise_cfg`, which can happen at the
+    # beginning of a schedule or in numerical edge cases): a raw division would produce
+    # `nan`/`inf` and silently corrupt the diffusion output (issue #13425). When the
+    # standard deviation of the guided prediction is zero, the rescaling is a no-op.
+    std_cfg = std_cfg.clamp(min=torch.finfo(noise_cfg.dtype).eps)
     noise_pred_rescaled = noise_cfg * (std_text / std_cfg)
     # mix with the original results from guidance by factor guidance_rescale to avoid "plain looking" images
     noise_cfg = guidance_rescale * noise_pred_rescaled + (1 - guidance_rescale) * noise_cfg