ledits_pp model/pipeline review

[hlky]

ledits_pp model/pipeline review

Commit tested: 0f1abc4ae8b0eb2a3b40e82a310507281144c423

Review performed against the repository review rules.

Coverage checked: fast and slow test classes exist for both SD and SDXL LEdits++; fast tests passed locally with .venv (3 passed, 1 skipped for each file). Slow tests exist but were not run. Duplicate search was run with gh search issues/prs; no duplicates found for the issues below. Existing open issue #8826 covers a separate known LEdits++ empty attention-store crash, so I am not presenting that one as new.

Issue 1: LEditsPPInversionPipelineOutput is missing from lazy exports

Affected code:

diffusers/src/diffusers/pipelines/ledits_pp/__init__.py

Lines 24 to 27 in 0f1abc4

	_import_structure["pipeline_leditspp_stable_diffusion"] = ["LEditsPPPipelineStableDiffusion"]
	_import_structure["pipeline_leditspp_stable_diffusion_xl"] = ["LEditsPPPipelineStableDiffusionXL"]
	_import_structure["pipeline_output"] = ["LEditsPPDiffusionPipelineOutput", "LEditsPPDiffusionPipelineOutput"]

Problem:
The lazy import structure exports LEditsPPDiffusionPipelineOutput twice and omits LEditsPPInversionPipelineOutput. The eager TYPE_CHECKING path imports both outputs, so behavior differs between slow/eager imports and normal lazy imports. diffusers.pipelines.__init__ also imports these outputs in the eager path but does not expose them in the lazy import structure.

Impact:
Public imports documented under pipelines.ledits_pp fail at runtime for the inversion output class.

Reproduction:

from diffusers.pipelines.ledits_pp import LEditsPPInversionPipelineOutput
# AttributeError: module diffusers.pipelines.ledits_pp has no attribute LEditsPPInversionPipelineOutput

Relevant precedent:

diffusers/src/diffusers/pipelines/ledits_pp/pipeline_output.py

Lines 27 to 42 in 0f1abc4

	@dataclass
	class LEditsPPInversionPipelineOutput(BaseOutput):
	"""
	Output class for LEdits++ Diffusion pipelines.
	Args:
	input_images (`list[PIL.Image.Image]` or `np.ndarray`)
	list of the cropped and resized input images as PIL images of length `batch_size` or NumPy array of shape `
	(batch_size, height, width, num_channels)`.
	vae_reconstruction_images (`list[PIL.Image.Image]` or `np.ndarray`)
	list of VAE reconstruction of all input images as PIL images of length `batch_size` or NumPy array of shape
	` (batch_size, height, width, num_channels)`.
	"""
	images: list[PIL.Image.Image] | np.ndarray
	vae_reconstruction_images: list[PIL.Image.Image] | np.ndarray

Suggested fix:

_import_structure["pipeline_output"] = [
 "LEditsPPDiffusionPipelineOutput",
 "LEditsPPInversionPipelineOutput",
]

Also either add both output classes to src/diffusers/pipelines/__init__.py lazy exports or remove the eager-only imports there.

Issue 2: SDXL editing after batched inversion has inconsistent embedding batch sizes

Affected code:

diffusers/src/diffusers/pipelines/ledits_pp/pipeline_leditspp_stable_diffusion_xl.py

Lines 538 to 558 in 0f1abc4

	if enable_edit_guidance and editing_prompt_embeds is None:
	editing_prompt_2 = editing_prompt
	editing_prompts = [editing_prompt, editing_prompt_2]
	edit_prompt_embeds_list = []
	for editing_prompt, tokenizer, text_encoder in zip(editing_prompts, tokenizers, text_encoders):
	if isinstance(self, TextualInversionLoaderMixin):
	editing_prompt = self.maybe_convert_prompt(editing_prompt, tokenizer)
	max_length = negative_prompt_embeds.shape[1]
	edit_concepts_input = tokenizer(
	# [x for item in editing_prompt for x in repeat(item, batch_size)],
	editing_prompt,
	padding="max_length",
	max_length=max_length,
	truncation=True,
	return_tensors="pt",
	return_length=True,
	)
	num_edit_tokens = edit_concepts_input.length - 2

diffusers/src/diffusers/pipelines/ledits_pp/pipeline_leditspp_stable_diffusion_xl.py

Lines 1112 to 1121 in 0f1abc4

	if enable_edit_guidance:
	prompt_embeds = torch.cat([prompt_embeds, edit_prompt_embeds], dim=0)
	add_text_embeds = torch.cat([add_text_embeds, pooled_edit_embeds], dim=0)
	edit_concepts_time_ids = add_time_ids.repeat(edit_prompt_embeds.shape[0], 1)
	add_time_ids = torch.cat([add_time_ids, edit_concepts_time_ids], dim=0)
	self.text_cross_attention_maps = [editing_prompt] if isinstance(editing_prompt, str) else editing_prompt
	prompt_embeds = prompt_embeds.to(device)
	add_text_embeds = add_text_embeds.to(device)
	add_time_ids = add_time_ids.to(device).repeat(batch_size * num_images_per_prompt, 1)

Problem:
LEditsPPPipelineStableDiffusionXL.encode_prompt() encodes edit concepts once per concept, not once per (concept, image) pair. After batched inversion, latents are repeated by 1 + enabled_editing_prompts, but edit prompt embeddings and pooled embeddings are not expanded the same way.

Impact:
SDXL LEdits++ cannot edit a batch of inverted images with multiple edit prompts. The failure is currently untested because fast tests cover batched inversion only, not batched editing.

Reproduction:

from diffusers import LEditsPPPipelineStableDiffusionXL
from tests.pipelines.ledits_pp.test_ledits_pp_stable_diffusion_xl import LEditsPPPipelineStableDiffusionXLFastTests

case = LEditsPPPipelineStableDiffusionXLFastTests()
pipe = LEditsPPPipelineStableDiffusionXL(**case.get_dummy_components())
pipe.set_progress_bar_config(disable=True)

inputs = case.get_dummy_inversion_inputs("cpu")
inputs["num_inversion_steps"] = 2
inputs["skip"] = 0.0
pipe.invert(**inputs)

pipe(editing_prompt=["wearing glasses", "sunshine"], output_type="latent")
# RuntimeError: mat1 and mat2 shapes cannot be multiplied ...

Relevant precedent:

diffusers/src/diffusers/pipelines/ledits_pp/pipeline_leditspp_stable_diffusion.py

Lines 632 to 645 in 0f1abc4

	text_inputs = self.tokenizer(
	[x for item in editing_prompt for x in repeat(item, batch_size)],
	padding="max_length",
	max_length=max_length,
	truncation=True,
	return_tensors="pt",
	return_length=True,
	)
	num_edit_tokens = text_inputs.length - 2 # not counting startoftext and endoftext
	text_input_ids = text_inputs.input_ids
	untruncated_ids = self.tokenizer(
	[x for item in editing_prompt for x in repeat(item, batch_size)],
	padding="longest",

Suggested fix:
Expand edit concept embeddings per image in __call__ or encode_prompt, while keeping num_edit_tokens indexed per concept. The implementation should preserve the inversion path, where editing_prompt is reused as the source prompt and already represents one prompt per image.

Issue 3: SDXL non-square image sizes are swapped for micro-conditioning

Affected code:

diffusers/src/diffusers/pipelines/ledits_pp/pipeline_leditspp_stable_diffusion_xl.py

Lines 1574 to 1576 in 0f1abc4

	width = x0.shape[2] * self.vae_scale_factor
	height = x0.shape[3] * self.vae_scale_factor
	self.size = (height, width)

diffusers/src/diffusers/pipelines/ledits_pp/pipeline_leditspp_stable_diffusion_xl.py

Lines 1103 to 1110 in 0f1abc4

	add_text_embeds = negative_pooled_prompt_embeds
	add_time_ids = self._get_add_time_ids(
	self.size,
	crops_coords_top_left,
	self.size,
	dtype=negative_pooled_prompt_embeds.dtype,
	text_encoder_projection_dim=text_encoder_projection_dim,
	)

Problem:
invert() computes width from latent height and height from latent width, then stores self.size = (height, width). For non-square images, SDXL added time IDs receive swapped original/target sizes. The target_size argument accepted by __call__ is also ignored; the call always uses self.size.

Impact:
Non-square SDXL edits are conditioned on the wrong dimensions, which can degrade output and makes the documented target_size parameter ineffective.

Reproduction:

from diffusers import LEditsPPPipelineStableDiffusionXL
from tests.pipelines.ledits_pp.test_ledits_pp_stable_diffusion_xl import LEditsPPPipelineStableDiffusionXLFastTests

case = LEditsPPPipelineStableDiffusionXLFastTests()
pipe = LEditsPPPipelineStableDiffusionXL(**case.get_dummy_components())
pipe.set_progress_bar_config(disable=True)

inputs = case.get_dummy_inversion_inputs("cpu")
inputs["image"] = inputs["image"][0].resize((64, 32))
inputs.update({"height": 32, "width": 64, "num_inversion_steps": 2, "skip": 0.0})
pipe.invert(**inputs)

print(pipe.size) # (64, 32), expected (32, 64)

Relevant precedent:

diffusers/src/diffusers/pipelines/stable_diffusion_xl/pipeline_stable_diffusion_xl.py

Lines 1030 to 1031 in 0f1abc4

	original_size = original_size or (height, width)
	target_size = target_size or (height, width)

Suggested fix:

height = x0.shape[-2] * self.vae_scale_factor
width = x0.shape[-1] * self.vae_scale_factor
self.size = (height, width)

Then use target_size = target_size or self.size in __call__.

Issue 4: Callback tensor allowlists include names that are not in scope

Affected code:

diffusers/src/diffusers/pipelines/ledits_pp/pipeline_leditspp_stable_diffusion.py

Lines 301 to 304 in 0f1abc4

	model_cpu_offload_seq = "text_encoder->unet->vae"
	_exclude_from_cpu_offload = ["safety_checker"]
	_callback_tensor_inputs = ["latents", "prompt_embeds", "negative_prompt_embeds"]
	_optional_components = ["safety_checker", "feature_extractor", "image_encoder"]

diffusers/src/diffusers/pipelines/ledits_pp/pipeline_leditspp_stable_diffusion.py

Lines 1235 to 1243 in 0f1abc4

	if callback_on_step_end is not None:
	callback_kwargs = {}
	for k in callback_on_step_end_tensor_inputs:
	callback_kwargs[k] = locals()[k]
	callback_outputs = callback_on_step_end(self, i, t, callback_kwargs)
	latents = callback_outputs.pop("latents", latents)
	# prompt_embeds = callback_outputs.pop("prompt_embeds", prompt_embeds)
	negative_prompt_embeds = callback_outputs.pop("negative_prompt_embeds", negative_prompt_embeds)

diffusers/src/diffusers/pipelines/ledits_pp/pipeline_leditspp_stable_diffusion_xl.py

Lines 336 to 344 in 0f1abc4

	_callback_tensor_inputs = [
	"latents",
	"prompt_embeds",
	"negative_prompt_embeds",
	"add_text_embeds",
	"add_time_ids",
	"negative_pooled_prompt_embeds",
	"negative_add_time_ids",
	]

diffusers/src/diffusers/pipelines/ledits_pp/pipeline_leditspp_stable_diffusion_xl.py

Lines 1016 to 1026 in 0f1abc4

	# TODO: Check inputs
	# 1. Check inputs. Raise error if not correct
	# self.check_inputs(
	# callback_steps,
	# negative_prompt,
	# negative_prompt_2,
	# prompt_embeds,
	# negative_prompt_embeds,
	# pooled_prompt_embeds,
	# negative_pooled_prompt_embeds,
	# )

Problem:
The SD pipeline allows prompt_embeds, but the denoising loop has no prompt_embeds local. The SDXL pipeline allows negative_add_time_ids, but that local is commented out and never defined; SDXL also comments out its check_inputs() call, so invalid callback tensor names are not rejected early.

Impact:
Documented callback customization crashes with KeyError instead of either passing the requested tensor or raising the normal validation error.

Reproduction:

from diffusers import LEditsPPPipelineStableDiffusion
from tests.pipelines.ledits_pp.test_ledits_pp_stable_diffusion import LEditsPPPipelineStableDiffusionFastTests

case = LEditsPPPipelineStableDiffusionFastTests()
pipe = LEditsPPPipelineStableDiffusion(**case.get_dummy_components())
pipe.set_progress_bar_config(disable=True)

inputs = case.get_dummy_inversion_inputs("cpu")
inputs.update({"image": inputs["image"][0], "num_inversion_steps": 1, "skip": 0.0})
pipe.invert(**inputs)

def cb(pipe, step, timestep, kwargs):
 return kwargs

pipe(
 editing_prompt="cat",
 output_type="latent",
 use_intersect_mask=False,
 callback_on_step_end=cb,
 callback_on_step_end_tensor_inputs=["prompt_embeds"],
)
# KeyError: 'prompt_embeds'

Relevant precedent:

diffusers/src/diffusers/pipelines/stable_diffusion_xl/pipeline_stable_diffusion_xl.py

Lines 232 to 237 in 0f1abc4

	_callback_tensor_inputs = [
	"latents",
	"prompt_embeds",
	"add_text_embeds",
	"add_time_ids",
	]

diffusers/src/diffusers/pipelines/stable_diffusion_xl/pipeline_stable_diffusion_xl.py

Lines 636 to 640 in 0f1abc4

	if callback_on_step_end_tensor_inputs is not None and not all(
	k in self._callback_tensor_inputs for k in callback_on_step_end_tensor_inputs
	):
	raise ValueError(
	f"`callback_on_step_end_tensor_inputs` has to be in {self._callback_tensor_inputs}, but found {[k for k in callback_on_step_end_tensor_inputs if k not in self._callback_tensor_inputs]}"

Suggested fix:
Make _callback_tensor_inputs match actual denoising-loop locals, call check_inputs() in SDXL, and add focused fast tests for every allowed callback tensor.

Issue 5: SDXL IP-Adapter path calls the VAE image encoder instead of IP-Adapter encoding

Affected code:

diffusers/src/diffusers/pipelines/ledits_pp/pipeline_leditspp_stable_diffusion_xl.py

Lines 1123 to 1128 in 0f1abc4

	if ip_adapter_image is not None:
	# TODO: fix image encoding
	image_embeds, negative_image_embeds = self.encode_image(ip_adapter_image, device, num_images_per_prompt)
	if self.do_classifier_free_guidance:
	image_embeds = torch.cat([negative_image_embeds, image_embeds])
	image_embeds = image_embeds.to(device)

diffusers/src/diffusers/pipelines/ledits_pp/pipeline_leditspp_stable_diffusion_xl.py

Lines 1440 to 1473 in 0f1abc4

	# Modified from diffusers.pipelines.ledits_pp.pipeline_leditspp_stable_diffusion.LEditsPPPipelineStableDiffusion.encode_image
	def encode_image(self, image, dtype=None, height=None, width=None, resize_mode="default", crops_coords=None):
	image = self.image_processor.preprocess(
	image=image, height=height, width=width, resize_mode=resize_mode, crops_coords=crops_coords
	)
	height, width = image.shape[-2:]
	if height % 32 != 0 or width % 32 != 0:
	raise ValueError(
	"Image height and width must be a factor of 32. "
	"Consider down-sampling the input using the `height` and `width` parameters"
	)
	resized = self.image_processor.postprocess(image=image, output_type="pil")
	if max(image.shape[-2:]) > self.vae.config["sample_size"] * 1.5:
	logger.warning(
	"Your input images far exceed the default resolution of the underlying diffusion model. "
	"The output images may contain severe artifacts! "
	"Consider down-sampling the input using the `height` and `width` parameters"
	)
	image = image.to(self.device, dtype=dtype)
	needs_upcasting = self.vae.dtype == torch.float16 and self.vae.config.force_upcast
	if needs_upcasting:
	image = image.float()
	self.upcast_vae()
	x0 = self.vae.encode(image).latent_dist.mode()
	x0 = x0.to(dtype)
	# cast back to fp16 if needed
	if needs_upcasting:
	self.vae.to(dtype=torch.float16)
	x0 = self.vae.config.scaling_factor * x0
	return x0, resized

Problem:
__call__() accepts ip_adapter_image, but calls self.encode_image(ip_adapter_image, device, num_images_per_prompt). In this pipeline, encode_image() is the VAE inversion helper, not the CLIP/IP-Adapter image encoder from SDXL. The positional arguments are interpreted as dtype and height.

Impact:
The advertised IP-Adapter path is unusable and fails before preparing image embeddings.

Reproduction:

from diffusers import LEditsPPPipelineStableDiffusionXL
from tests.pipelines.ledits_pp.test_ledits_pp_stable_diffusion_xl import LEditsPPPipelineStableDiffusionXLFastTests

case = LEditsPPPipelineStableDiffusionXLFastTests()
pipe = LEditsPPPipelineStableDiffusionXL(**case.get_dummy_components())
pipe.set_progress_bar_config(disable=True)

inputs = case.get_dummy_inversion_inputs("cpu")
inputs.update({"image": inputs["image"][0], "num_inversion_steps": 1, "skip": 0.0})
pipe.invert(**inputs)

pipe(editing_prompt="cat", ip_adapter_image=inputs["image"], output_type="latent")
# ValueError: height and width must be > 0

Relevant precedent:

diffusers/src/diffusers/pipelines/stable_diffusion_xl/pipeline_stable_diffusion_xl.py

Lines 522 to 590 in 0f1abc4

	def encode_image(self, image, device, num_images_per_prompt, output_hidden_states=None):
	dtype = next(self.image_encoder.parameters()).dtype
	if not isinstance(image, torch.Tensor):
	image = self.feature_extractor(image, return_tensors="pt").pixel_values
	image = image.to(device=device, dtype=dtype)
	if output_hidden_states:
	image_enc_hidden_states = self.image_encoder(image, output_hidden_states=True).hidden_states[-2]
	image_enc_hidden_states = image_enc_hidden_states.repeat_interleave(num_images_per_prompt, dim=0)
	uncond_image_enc_hidden_states = self.image_encoder(
	torch.zeros_like(image), output_hidden_states=True
	).hidden_states[-2]
	uncond_image_enc_hidden_states = uncond_image_enc_hidden_states.repeat_interleave(
	num_images_per_prompt, dim=0
	)
	return image_enc_hidden_states, uncond_image_enc_hidden_states
	else:
	image_embeds = self.image_encoder(image).image_embeds
	image_embeds = image_embeds.repeat_interleave(num_images_per_prompt, dim=0)
	uncond_image_embeds = torch.zeros_like(image_embeds)
	return image_embeds, uncond_image_embeds
	# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.prepare_ip_adapter_image_embeds
	def prepare_ip_adapter_image_embeds(
	self, ip_adapter_image, ip_adapter_image_embeds, device, num_images_per_prompt, do_classifier_free_guidance
	):
	image_embeds = []
	if do_classifier_free_guidance:
	negative_image_embeds = []
	if ip_adapter_image_embeds is None:
	if not isinstance(ip_adapter_image, list):
	ip_adapter_image = [ip_adapter_image]
	if len(ip_adapter_image) != len(self.unet.encoder_hid_proj.image_projection_layers):
	raise ValueError(
	f"`ip_adapter_image` must have same length as the number of IP Adapters. Got {len(ip_adapter_image)} images and {len(self.unet.encoder_hid_proj.image_projection_layers)} IP Adapters."
	)
	for single_ip_adapter_image, image_proj_layer in zip(
	ip_adapter_image, self.unet.encoder_hid_proj.image_projection_layers
	):
	output_hidden_state = not isinstance(image_proj_layer, ImageProjection)
	single_image_embeds, single_negative_image_embeds = self.encode_image(
	single_ip_adapter_image, device, 1, output_hidden_state
	)
	image_embeds.append(single_image_embeds[None, :])
	if do_classifier_free_guidance:
	negative_image_embeds.append(single_negative_image_embeds[None, :])
	else:
	for single_image_embeds in ip_adapter_image_embeds:
	if do_classifier_free_guidance:
	single_negative_image_embeds, single_image_embeds = single_image_embeds.chunk(2)
	negative_image_embeds.append(single_negative_image_embeds)
	image_embeds.append(single_image_embeds)
	ip_adapter_image_embeds = []
	for i, single_image_embeds in enumerate(image_embeds):
	single_image_embeds = torch.cat([single_image_embeds] * num_images_per_prompt, dim=0)
	if do_classifier_free_guidance:
	single_negative_image_embeds = torch.cat([negative_image_embeds[i]] * num_images_per_prompt, dim=0)
	single_image_embeds = torch.cat([single_negative_image_embeds, single_image_embeds], dim=0)
	single_image_embeds = single_image_embeds.to(device=device)
	ip_adapter_image_embeds.append(single_image_embeds)
	return ip_adapter_image_embeds

diffusers/src/diffusers/pipelines/stable_diffusion_xl/pipeline_stable_diffusion_xl.py

Lines 1153 to 1160 in 0f1abc4

	if ip_adapter_image is not None or ip_adapter_image_embeds is not None:
	image_embeds = self.prepare_ip_adapter_image_embeds(
	ip_adapter_image,
	ip_adapter_image_embeds,
	device,
	batch_size * num_images_per_prompt,
	self.do_classifier_free_guidance,
	)

Suggested fix:
Rename the VAE helper to something like encode_vae_image(), restore/copy SDXL’s encode_image() and prepare_ip_adapter_image_embeds(), add ip_adapter_image_embeds, and include image_encoder in the offload sequence.

Issue 6: invert() and cross-attention masking permanently replace user attention processors

Affected code:

diffusers/src/diffusers/pipelines/ledits_pp/pipeline_leditspp_stable_diffusion.py

Lines 497 to 519 in 0f1abc4

	def prepare_unet(self, attention_store, PnP: bool = False):
	attn_procs = {}
	for name in self.unet.attn_processors.keys():
	if name.startswith("mid_block"):
	place_in_unet = "mid"
	elif name.startswith("up_blocks"):
	place_in_unet = "up"
	elif name.startswith("down_blocks"):
	place_in_unet = "down"
	else:
	continue
	if "attn2" in name and place_in_unet != "mid":
	attn_procs[name] = LEDITSCrossAttnProcessor(
	attention_store=attention_store,
	place_in_unet=place_in_unet,
	pnp=PnP,
	editing_prompts=self.enabled_editing_prompts,
	)
	else:
	attn_procs[name] = AttnProcessor()
	self.unet.set_attn_processor(attn_procs)

diffusers/src/diffusers/pipelines/ledits_pp/pipeline_leditspp_stable_diffusion.py

Lines 1343 to 1344 in 0f1abc4

	# Reset attn processor, we do not want to store attn maps during inversion
	self.unet.set_attn_processor(AttnProcessor())

diffusers/src/diffusers/pipelines/ledits_pp/pipeline_leditspp_stable_diffusion_xl.py

Lines 811 to 834 in 0f1abc4

	# Copied from diffusers.pipelines.ledits_pp.pipeline_leditspp_stable_diffusion.LEditsPPPipelineStableDiffusion.prepare_unet
	def prepare_unet(self, attention_store, PnP: bool = False):
	attn_procs = {}
	for name in self.unet.attn_processors.keys():
	if name.startswith("mid_block"):
	place_in_unet = "mid"
	elif name.startswith("up_blocks"):
	place_in_unet = "up"
	elif name.startswith("down_blocks"):
	place_in_unet = "down"
	else:
	continue
	if "attn2" in name and place_in_unet != "mid":
	attn_procs[name] = LEDITSCrossAttnProcessor(
	attention_store=attention_store,
	place_in_unet=place_in_unet,
	pnp=PnP,
	editing_prompts=self.enabled_editing_prompts,
	)
	else:
	attn_procs[name] = AttnProcessor()
	self.unet.set_attn_processor(attn_procs)

diffusers/src/diffusers/pipelines/ledits_pp/pipeline_leditspp_stable_diffusion_xl.py

Lines 1543 to 1544 in 0f1abc4

	# Reset attn processor, we do not want to store attn maps during inversion
	self.unet.set_attn_processor(AttnProcessor())

Problem:
invert() unconditionally calls self.unet.set_attn_processor(AttnProcessor()). prepare_unet() also replaces all processors with either LEDITSCrossAttnProcessor or plain AttnProcessor(). Neither path restores the original processors.

Impact:
Any configured attention backend or custom processor, including AttnProcessor2_0, xFormers-style processors, LoRA/IP-Adapter processors, or user-supplied processors, is silently discarded after inversion or masked editing.

Reproduction:

from diffusers import LEditsPPPipelineStableDiffusion
from diffusers.models.attention_processor import AttnProcessor2_0
from tests.pipelines.ledits_pp.test_ledits_pp_stable_diffusion import LEditsPPPipelineStableDiffusionFastTests

case = LEditsPPPipelineStableDiffusionFastTests()
pipe = LEditsPPPipelineStableDiffusion(**case.get_dummy_components())
pipe.unet.set_attn_processor(AttnProcessor2_0())

before = {type(p).__name__ for p in pipe.unet.attn_processors.values()}

inputs = case.get_dummy_inversion_inputs("cpu")
inputs.update({"image": inputs["image"][0], "num_inversion_steps": 1, "skip": 0.0})
pipe.set_progress_bar_config(disable=True)
pipe.invert(**inputs)

after = {type(p).__name__ for p in pipe.unet.attn_processors.values()}
print(before, after) # {'AttnProcessor2_0'} {'AttnProcessor'}

Relevant precedent:

diffusers/src/diffusers/models/attention_processor.py

Lines 2696 to 2786 in 0f1abc4

	class AttnProcessor2_0:
	r"""
	Processor for implementing scaled dot-product attention (enabled by default if you're using PyTorch 2.0).
	"""
	def __init__(self):
	if not hasattr(F, "scaled_dot_product_attention"):
	raise ImportError("AttnProcessor2_0 requires PyTorch 2.0, to use it, please upgrade PyTorch to 2.0.")
	def __call__(
	self,
	attn: Attention,
	hidden_states: torch.Tensor,
	encoder_hidden_states: torch.Tensor | None = None,
	attention_mask: torch.Tensor | None = None,
	temb: torch.Tensor | None = None,
	*args,
	**kwargs,
	) -> torch.Tensor:
	if len(args) > 0 or kwargs.get("scale", None) is not None:
	deprecation_message = "The `scale` argument is deprecated and will be ignored. Please remove it, as passing it will raise an error in the future. `scale` should directly be passed while calling the underlying pipeline component i.e., via `cross_attention_kwargs`."
	deprecate("scale", "1.0.0", deprecation_message)
	residual = hidden_states
	if attn.spatial_norm is not None:
	hidden_states = attn.spatial_norm(hidden_states, temb)
	input_ndim = hidden_states.ndim
	if input_ndim == 4:
	batch_size, channel, height, width = hidden_states.shape
	hidden_states = hidden_states.view(batch_size, channel, height * width).transpose(1, 2)
	batch_size, sequence_length, _ = (
	hidden_states.shape if encoder_hidden_states is None else encoder_hidden_states.shape
	)
	if attention_mask is not None:
	attention_mask = attn.prepare_attention_mask(attention_mask, sequence_length, batch_size)
	# scaled_dot_product_attention expects attention_mask shape to be
	# (batch, heads, source_length, target_length)
	attention_mask = attention_mask.view(batch_size, attn.heads, -1, attention_mask.shape[-1])
	if attn.group_norm is not None:
	hidden_states = attn.group_norm(hidden_states.transpose(1, 2)).transpose(1, 2)
	query = attn.to_q(hidden_states)
	if encoder_hidden_states is None:
	encoder_hidden_states = hidden_states
	elif attn.norm_cross:
	encoder_hidden_states = attn.norm_encoder_hidden_states(encoder_hidden_states)
	key = attn.to_k(encoder_hidden_states)
	value = attn.to_v(encoder_hidden_states)
	inner_dim = key.shape[-1]
	head_dim = inner_dim // attn.heads
	query = query.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2)
	key = key.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2)
	value = value.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2)
	if attn.norm_q is not None:
	query = attn.norm_q(query)
	if attn.norm_k is not None:
	key = attn.norm_k(key)
	# the output of sdp = (batch, num_heads, seq_len, head_dim)
	# TODO: add support for attn.scale when we move to Torch 2.1
	hidden_states = F.scaled_dot_product_attention(
	query, key, value, attn_mask=attention_mask, dropout_p=0.0, is_causal=False
	)
	hidden_states = hidden_states.transpose(1, 2).reshape(batch_size, -1, attn.heads * head_dim)
	hidden_states = hidden_states.to(query.dtype)
	# linear proj
	hidden_states = attn.to_out[0](hidden_states)
	# dropout
	hidden_states = attn.to_out[1](hidden_states)
	if input_ndim == 4:
	hidden_states = hidden_states.transpose(-1, -2).reshape(batch_size, channel, height, width)
	if attn.residual_connection:
	hidden_states = hidden_states + residual
	hidden_states = hidden_states / attn.rescale_output_factor

Suggested fix:
Store the original unet.attn_processors before installing LEdits processors and restore them in a finally block after the temporary operation. For non-intercepted attention layers, preserve the existing processor instead of replacing it with bare AttnProcessor().

Issue 7: CPU offload paths use self.device instead of _execution_device

Affected code:

diffusers/src/diffusers/pipelines/ledits_pp/pipeline_leditspp_stable_diffusion.py

Lines 948 to 995 in 0f1abc4

	edit_concepts, uncond_embeddings, num_edit_tokens = self.encode_prompt(
	editing_prompt=editing_prompt,
	device=self.device,
	num_images_per_prompt=num_images_per_prompt,
	enable_edit_guidance=enable_edit_guidance,
	negative_prompt=negative_prompt,
	editing_prompt_embeds=editing_prompt_embeds,
	negative_prompt_embeds=negative_prompt_embeds,
	lora_scale=lora_scale,
	clip_skip=self.clip_skip,
	)
	# For classifier free guidance, we need to do two forward passes.
	# Here we concatenate the unconditional and text embeddings into a single batch
	# to avoid doing two forward passes
	if enable_edit_guidance:
	text_embeddings = torch.cat([uncond_embeddings, edit_concepts])
	self.text_cross_attention_maps = [editing_prompt] if isinstance(editing_prompt, str) else editing_prompt
	else:
	text_embeddings = torch.cat([uncond_embeddings])
	# 4. Prepare timesteps
	# self.scheduler.set_timesteps(num_inference_steps, device=self.device)
	timesteps = self.inversion_steps
	t_to_idx = {int(v): k for k, v in enumerate(timesteps[-zs.shape[0] :])}
	if use_cross_attn_mask:
	self.attention_store = LeditsAttentionStore(
	average=store_averaged_over_steps,
	batch_size=batch_size,
	max_size=(latents.shape[-2] / 4.0) * (latents.shape[-1] / 4.0),
	max_resolution=None,
	)
	self.prepare_unet(self.attention_store, PnP=False)
	resolution = latents.shape[-2:]
	att_res = (int(resolution[0] / 4), int(resolution[1] / 4))
	# 5. Prepare latent variables
	num_channels_latents = self.unet.config.in_channels
	latents = self.prepare_latents(
	batch_size * num_images_per_prompt,
	num_channels_latents,
	None,
	None,
	text_embeddings.dtype,
	self.device,
	latents,
	)

diffusers/src/diffusers/pipelines/ledits_pp/pipeline_leditspp_stable_diffusion.py

Lines 1388 to 1398 in 0f1abc4

	xts = torch.zeros(size=variance_noise_shape, device=self.device, dtype=uncond_embedding.dtype)
	for t in reversed(timesteps):
	idx = num_inversion_steps - t_to_idx[int(t)] - 1
	noise = randn_tensor(shape=x0.shape, generator=generator, device=self.device, dtype=x0.dtype)
	xts[idx] = self.scheduler.add_noise(x0, noise, torch.Tensor([t]))
	xts = torch.cat([x0.unsqueeze(0), xts], dim=0)
	self.scheduler.set_timesteps(len(self.scheduler.timesteps))
	# noise maps
	zs = torch.zeros(size=variance_noise_shape, device=self.device, dtype=uncond_embedding.dtype)

diffusers/src/diffusers/pipelines/ledits_pp/pipeline_leditspp_stable_diffusion_xl.py

Lines 1010 to 1014 in 0f1abc4

	if use_cross_attn_mask:
	self.smoothing = LeditsGaussianSmoothing(self.device)
	if user_mask is not None:
	user_mask = user_mask.to(self.device)

diffusers/src/diffusers/pipelines/ledits_pp/pipeline_leditspp_stable_diffusion_xl.py

Lines 1459 to 1467 in 0f1abc4

	image = image.to(self.device, dtype=dtype)
	needs_upcasting = self.vae.dtype == torch.float16 and self.vae.config.force_upcast
	if needs_upcasting:
	image = image.float()
	self.upcast_vae()
	x0 = self.vae.encode(image).latent_dist.mode()
	x0 = x0.to(dtype)

diffusers/src/diffusers/pipelines/ledits_pp/pipeline_leditspp_stable_diffusion_xl.py

Lines 1650 to 1655 in 0f1abc4

	xts = torch.zeros(size=variance_noise_shape, device=self.device, dtype=negative_prompt_embeds.dtype)
	for t in reversed(timesteps):
	idx = num_inversion_steps - t_to_idx[int(t)] - 1
	noise = randn_tensor(shape=x0.shape, generator=generator, device=self.device, dtype=x0.dtype)
	xts[idx] = self.scheduler.add_noise(x0, noise, t.unsqueeze(0))

Problem:
Both pipelines declare model_cpu_offload_seq, but many runtime tensors are moved to self.device. Under enable_model_cpu_offload(), self.device can remain CPU while _execution_device is the actual accelerator. Standard pipelines use _execution_device at call time for this reason.

Impact:
CPU offload can put prompts, latents, masks, smoothing kernels, and inversion noise on the wrong device, causing device mismatches or unexpectedly running heavy work on CPU.

Reproduction:

import torch
from diffusers import LEditsPPPipelineStableDiffusionXL
from tests.pipelines.ledits_pp.test_ledits_pp_stable_diffusion_xl import LEditsPPPipelineStableDiffusionXLFastTests

if not torch.cuda.is_available():
 raise SystemExit("requires CUDA to exercise model CPU offload")

case = LEditsPPPipelineStableDiffusionXLFastTests()
pipe = LEditsPPPipelineStableDiffusionXL(**case.get_dummy_components())
pipe.enable_model_cpu_offload()
print(pipe.device, pipe._execution_device) # CPU vs CUDA under offload

inputs = case.get_dummy_inversion_inputs("cpu")
inputs.update({"image": inputs["image"][0], "num_inversion_steps": 2, "skip": 0.0})
pipe.invert(**inputs)
pipe(editing_prompt="cat", output_type="latent", use_cross_attn_mask=True)

Relevant precedent:

diffusers/src/diffusers/pipelines/stable_diffusion/pipeline_stable_diffusion.py

Line 955 in 0f1abc4

device = self._execution_device

diffusers/src/diffusers/pipelines/latent_consistency_models/pipeline_latent_consistency_text2img.py

Line 786 in 0f1abc4

device = self._execution_device

diffusers/src/diffusers/pipelines/latent_consistency_models/pipeline_latent_consistency_img2img.py

Line 849 in 0f1abc4

device = self._execution_device

Suggested fix:
At the start of __call__() and invert(), set device = self._execution_device and use that local for tensor movement/allocation. Pass device into VAE image encoding helpers instead of reading self.device inside them.

[LuShadowX]

Issue 4 reproduces on current main (50e7158): callback_on_step_end_tensor_inputs=["prompt_embeds"] raises KeyError: 'prompt_embeds' on the SD pipeline, and negative_add_time_ids does the same on SDXL.

I have a fix ready that trims both allowlists to the actual denoising-loop locals, plus a test_callback_inputs fast test in each LEdits++ test class — those classes are plain unittest.TestCase, so the PipelineTesterMixin callback tests never ran against them. Both new tests fail on main with the two KeyErrors and pass with the change (tests/pipelines/ledits_pp: 8 passed, 2 skipped).

An AST sweep over all of src/diffusers/pipelines for the same defect turned up one more pipeline outside ledits_pp that lists a name in _callback_tensor_inputs which is never bound in its __call__. Happy to fold it into the same PR so this lands as one systematic fix rather than two.

Not touched: the commented-out check_inputs() call in the SDXL pipeline that this issue also mentions.

OK to open the PR?