Guard against zero std_cfg in rescale_noise_cfg (#13425)

`rescale_noise_cfg` divides `std_text` by `std_cfg` without any numerical
guard. When `noise_cfg` has zero variance (e.g. a constant or zero-valued
guided prediction at the start of a schedule), `std_cfg` is `0`, the division
produces `nan`/`inf`, and `noise_cfg * (std_text / 0)` silently corrupts the
diffusion output (#13425).

Clamp `std_cfg` to `torch.finfo(noise_cfg.dtype).eps` before dividing so the
rescaling becomes a no-op in the degenerate case (`noise_cfg == 0` produces
`0 * <finite> == 0`) instead of `nan`.

Propagated to all 32 in-tree copies via `python utils/check_copies.py
--fix_and_overwrite`.

Author: jbbqqf

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