stable_cascade model/pipeline review

[hlky]

stable_cascade model/pipeline review

Commit tested: 0f1abc4ae8b0eb2a3b40e82a310507281144c423

Review performed against the repository review rules.

Reviewed: public imports/lazy loading, config/loading/single-file surface, runtime dtype/device paths, offload/xFormers delegation, model forward behavior, docs, fast/slow tests, and duplicate issues/PRs.

Duplicate search status: searched huggingface/diffusers Issues/PRs for stable_cascade, class names, prompt_embeds_pooled, image-conditioning inputs, latents dtype, timesteps, xFormers, and coverage. No exact duplicates found. Related but not duplicate: #7355/#7644 for older arbitrary-resolution dtype errors, and #7598 for bf16 image tensor preprocessing.

Issue 1: Single image conditioning inputs are advertised but rejected

Affected code:

diffusers/src/diffusers/pipelines/stable_cascade/pipeline_stable_cascade_prior.py

Lines 262 to 274 in 0f1abc4

	def encode_image(self, images, device, dtype, batch_size, num_images_per_prompt):
	image_embeds = []
	for image in images:
	image = self.feature_extractor(image, return_tensors="pt").pixel_values
	image = image.to(device=device, dtype=dtype)
	image_embed = self.image_encoder(image).image_embeds.unsqueeze(1)
	image_embeds.append(image_embed)
	image_embeds = torch.cat(image_embeds, dim=1)
	image_embeds = image_embeds.repeat(batch_size * num_images_per_prompt, 1, 1)
	negative_image_embeds = torch.zeros_like(image_embeds)
	return image_embeds, negative_image_embeds

diffusers/src/diffusers/pipelines/stable_cascade/pipeline_stable_cascade_prior.py

Lines 345 to 351 in 0f1abc4

	if images:
	for i, image in enumerate(images):
	if not isinstance(image, torch.Tensor) and not isinstance(image, PIL.Image.Image):
	raise TypeError(
	f"'images' must contain images of type 'torch.Tensor' or 'PIL.Image.Image, but got"
	f"{type(image)} for image number {i}."
	)

diffusers/src/diffusers/pipelines/stable_cascade/pipeline_stable_cascade_combined.py

Lines 162 to 164 in 0f1abc4

	prompt: str | list[str] | None = None,
	images: torch.Tensor | PIL.Image.Image | list[torch.Tensor] | list[PIL.Image.Image] = None,
	height: int = 512,

Problem:
StableCascadePriorPipeline and StableCascadeCombinedPipeline type-hint images as a single tensor/PIL image or a list, but check_inputs() uses if images: and then iterates images. A tensor raises ambiguous-bool errors, and a single PIL image raises 'Image' object is not iterable.

Impact:
Image-conditioned Stable Cascade calls fail for documented input forms unless users wrap the image in a list.

Reproduction:

from PIL import Image
import torch
from diffusers import DDPMWuerstchenScheduler, StableCascadePriorPipeline, StableCascadeUNet

prior = StableCascadeUNet(
 conditioning_dim=8, block_out_channels=(8,), num_attention_heads=(-1,),
 down_num_layers_per_block=(1,), up_num_layers_per_block=(1,),
 down_blocks_repeat_mappers=(1,), up_blocks_repeat_mappers=(1,),
 block_types_per_layer=(("SDCascadeResBlock", "SDCascadeTimestepBlock"),),
 clip_text_pooled_in_channels=8, clip_image_in_channels=8,
)
pipe = StableCascadePriorPipeline(None, None, prior, DDPMWuerstchenScheduler())

for images in [Image.new("RGB", (8, 8)), torch.zeros(3, 8, 8)]:
 try:
 pipe.check_inputs(prompt="cat", images=images)
 except Exception as e:
 print(type(e).__name__, str(e).splitlines()[0])

Relevant precedent:
Other image pipelines normalize single images to lists before iterating, for example pipeline_if_img2img.py.

Suggested fix:

if images is not None and not isinstance(images, list):
 images = [images]

Apply before validation and before encode_image().

Issue 2: Decoder precomputed prompt embeds break CFG unless negative pooled embeds are also supplied

Affected code:

diffusers/src/diffusers/pipelines/stable_cascade/pipeline_stable_cascade.py

Lines 241 to 280 in 0f1abc4

	def check_inputs(
	self,
	prompt,
	negative_prompt=None,
	prompt_embeds=None,
	negative_prompt_embeds=None,
	callback_on_step_end_tensor_inputs=None,
	):
	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]}"
	)
	if prompt is not None and prompt_embeds is not None:
	raise ValueError(
	f"Cannot forward both `prompt`: {prompt} and `prompt_embeds`: {prompt_embeds}. Please make sure to"
	" only forward one of the two."
	)
	elif prompt is None and prompt_embeds is None:
	raise ValueError(
	"Provide either `prompt` or `prompt_embeds`. Cannot leave both `prompt` and `prompt_embeds` undefined."
	)
	elif prompt is not None and (not isinstance(prompt, str) and not isinstance(prompt, list)):
	raise ValueError(f"`prompt` has to be of type `str` or `list` but is {type(prompt)}")
	if negative_prompt is not None and negative_prompt_embeds is not None:
	raise ValueError(
	f"Cannot forward both `negative_prompt`: {negative_prompt} and `negative_prompt_embeds`:"
	f" {negative_prompt_embeds}. Please make sure to only forward one of the two."
	)
	if prompt_embeds is not None and negative_prompt_embeds is not None:
	if prompt_embeds.shape != negative_prompt_embeds.shape:
	raise ValueError(
	"`prompt_embeds` and `negative_prompt_embeds` must have the same shape when passed directly, but"
	f" got: `prompt_embeds` {prompt_embeds.shape} != `negative_prompt_embeds`"
	f" {negative_prompt_embeds.shape}."
	)

diffusers/src/diffusers/pipelines/stable_cascade/pipeline_stable_cascade.py

Lines 422 to 440 in 0f1abc4

	# 2. Encode caption
	if prompt_embeds is None and negative_prompt_embeds is None:
	_, prompt_embeds_pooled, _, negative_prompt_embeds_pooled = self.encode_prompt(
	prompt=prompt,
	device=device,
	batch_size=batch_size,
	num_images_per_prompt=num_images_per_prompt,
	do_classifier_free_guidance=self.do_classifier_free_guidance,
	negative_prompt=negative_prompt,
	prompt_embeds=prompt_embeds,
	prompt_embeds_pooled=prompt_embeds_pooled,
	negative_prompt_embeds=negative_prompt_embeds,
	negative_prompt_embeds_pooled=negative_prompt_embeds_pooled,
	)
	# The pooled embeds from the prior are pooled again before being passed to the decoder
	prompt_embeds_pooled = (
	torch.cat([prompt_embeds_pooled, negative_prompt_embeds_pooled])
	if self.do_classifier_free_guidance

Problem:
The decoder only calls encode_prompt() when both prompt_embeds and negative_prompt_embeds are None. If a user supplies prompt_embeds/prompt_embeds_pooled and sets guidance_scale > 1, the pipeline never creates negative_prompt_embeds_pooled, then torch.cat() receives None.

Impact:
The documented precomputed-embedding path fails for classifier-free guidance instead of generating empty negative embeddings or raising a clear validation error.

Reproduction:

import torch
from diffusers import DDPMWuerstchenScheduler, StableCascadeDecoderPipeline, StableCascadeUNet

decoder = StableCascadeUNet(
 in_channels=4, out_channels=4, conditioning_dim=8, block_out_channels=(8,),
 num_attention_heads=(-1,), down_num_layers_per_block=(1,), up_num_layers_per_block=(1,),
 down_blocks_repeat_mappers=(1,), up_blocks_repeat_mappers=(1,),
 block_types_per_layer=(("SDCascadeResBlock", "SDCascadeTimestepBlock"),),
 clip_text_pooled_in_channels=8, effnet_in_channels=4,
)
pipe = StableCascadeDecoderPipeline(decoder, None, None, DDPMWuerstchenScheduler(), None, latent_dim_scale=1.0)

try:
 pipe(
 image_embeddings=torch.randn(1, 4, 1, 1),
 prompt_embeds=torch.randn(1, 77, 8),
 prompt_embeds_pooled=torch.randn(1, 1, 8),
 guidance_scale=2.0,
 num_inference_steps=1,
 output_type="latent",
 )
except Exception as e:
 print(type(e).__name__, str(e).splitlines()[0])

Relevant precedent:
StableCascadePriorPipeline.check_inputs() already validates pooled prompt embeddings.

Suggested fix:

if prompt_embeds is not None and prompt_embeds_pooled is None:
 raise ValueError("If `prompt_embeds` are provided, `prompt_embeds_pooled` must also be provided.")
if negative_prompt_embeds is not None and negative_prompt_embeds_pooled is None:
 raise ValueError("If `negative_prompt_embeds` are provided, `negative_prompt_embeds_pooled` must also be provided.")

if self.do_classifier_free_guidance and negative_prompt_embeds_pooled is None:
 _, _, _, negative_prompt_embeds_pooled = self.encode_prompt(...)

Issue 3: StableCascadeUNet.get_clip_embeddings() mishandles 2D pooled text embeddings

Affected code:

diffusers/src/diffusers/models/unets/unet_stable_cascade.py

Lines 432 to 448 in 0f1abc4

	def get_clip_embeddings(self, clip_txt_pooled, clip_txt=None, clip_img=None):
	if len(clip_txt_pooled.shape) == 2:
	clip_txt_pool = clip_txt_pooled.unsqueeze(1)
	clip_txt_pool = self.clip_txt_pooled_mapper(clip_txt_pooled).view(
	clip_txt_pooled.size(0), clip_txt_pooled.size(1) * self.config.clip_seq, -1
	)
	if clip_txt is not None and clip_img is not None:
	clip_txt = self.clip_txt_mapper(clip_txt)
	if len(clip_img.shape) == 2:
	clip_img = clip_img.unsqueeze(1)
	clip_img = self.clip_img_mapper(clip_img).view(
	clip_img.size(0), clip_img.size(1) * self.config.clip_seq, -1
	)
	clip = torch.cat([clip_txt, clip_txt_pool, clip_img], dim=1)
	else:
	clip = clip_txt_pool
	return self.clip_norm(clip)

Problem:
The method detects 2D clip_txt_pooled and assigns clip_txt_pool = clip_txt_pooled.unsqueeze(1), but then ignores that normalized tensor and maps/views the original 2D tensor.

Impact:
Users passing normal CLIP pooled embeddings shaped (batch, dim) hit a runtime shape error, even though the method appears intended to support that shape.

Reproduction:

import torch
from diffusers import StableCascadeUNet

model = StableCascadeUNet(
 conditioning_dim=8, block_out_channels=(8,), num_attention_heads=(-1,),
 down_num_layers_per_block=(1,), up_num_layers_per_block=(1,),
 down_blocks_repeat_mappers=(1,), up_blocks_repeat_mappers=(1,),
 block_types_per_layer=(("SDCascadeResBlock", "SDCascadeTimestepBlock"),),
 clip_text_pooled_in_channels=8,
)

try:
 model.get_clip_embeddings(torch.randn(1, 8))
except Exception as e:
 print(type(e).__name__, str(e).splitlines()[0])

Relevant precedent:
The pipelines produce pooled embeddings as (batch, 1, dim) internally; public direct model use should normalize 2D inputs to that same shape.

Suggested fix:

if clip_txt_pooled.ndim == 2:
 clip_txt_pooled = clip_txt_pooled.unsqueeze(1)

clip_txt_pool = self.clip_txt_pooled_mapper(clip_txt_pooled).view(
 clip_txt_pooled.size(0), clip_txt_pooled.size(1) * self.config.clip_seq, -1
)

Issue 4: sca/crp conditioning tensors crash batch forwards

Affected code:

diffusers/src/diffusers/models/unets/unet_stable_cascade.py

Lines 555 to 564 in 0f1abc4

	timestep_ratio_embed = self.get_timestep_ratio_embedding(timestep_ratio)
	for c in self.config.timestep_conditioning_type:
	if c == "sca":
	cond = sca
	elif c == "crp":
	cond = crp
	else:
	cond = None
	t_cond = cond or torch.zeros_like(timestep_ratio)
	timestep_ratio_embed = torch.cat([timestep_ratio_embed, self.get_timestep_ratio_embedding(t_cond)], dim=1)

Problem:
forward() uses t_cond = cond or torch.zeros_like(timestep_ratio). Tensor truthiness is invalid for batched tensors.

Impact:
The model exposes sca and crp conditioning parameters but cannot use them for normal batched inputs.

Reproduction:

import torch
from diffusers import StableCascadeUNet

model = StableCascadeUNet(
 in_channels=4, out_channels=4, conditioning_dim=8, block_out_channels=(8,),
 num_attention_heads=(-1,), down_num_layers_per_block=(1,), up_num_layers_per_block=(1,),
 down_blocks_repeat_mappers=(1,), up_blocks_repeat_mappers=(1,),
 block_types_per_layer=(("SDCascadeResBlock", "SDCascadeTimestepBlock"),),
 clip_text_pooled_in_channels=8,
)

try:
 model(
 sample=torch.randn(2, 4, 8, 8),
 timestep_ratio=torch.ones(2),
 clip_text_pooled=torch.randn(2, 1, 8),
 sca=torch.tensor([0.1, 0.2]),
 crp=torch.tensor([0.3, 0.4]),
 )
except Exception as e:
 print(type(e).__name__, str(e).splitlines()[0])

Relevant precedent:
Standard tensor optional handling uses explicit is None checks.

Suggested fix:

t_cond = cond if cond is not None else torch.zeros_like(timestep_ratio)

Issue 5: User-supplied latents are moved to device but not cast to pipeline dtype

Affected code:

diffusers/src/diffusers/pipelines/stable_cascade/pipeline_stable_cascade_prior.py

Lines 145 to 152 in 0f1abc4

	if latents is None:
	latents = randn_tensor(latent_shape, generator=generator, device=device, dtype=dtype)
	else:
	if latents.shape != latent_shape:
	raise ValueError(f"Unexpected latents shape, got {latents.shape}, expected {latent_shape}")
	latents = latents.to(device)
	latents = latents * scheduler.init_noise_sigma

diffusers/src/diffusers/pipelines/stable_cascade/pipeline_stable_cascade.py

Lines 124 to 131 in 0f1abc4

	if latents is None:
	latents = randn_tensor(latents_shape, generator=generator, device=device, dtype=dtype)
	else:
	if latents.shape != latents_shape:
	raise ValueError(f"Unexpected latents shape, got {latents.shape}, expected {latents_shape}")
	latents = latents.to(device)
	latents = latents * scheduler.init_noise_sigma

Problem:
Both prepare_latents() methods cast generated latents to dtype, but pre-generated latents only call .to(device). Passing float32 latents to bf16/fp16 weights preserves float32 and can fail in convolutions.

Impact:
Reusing deterministic latents with half/bfloat16 Stable Cascade can error or silently change compute behavior. Related dtype-error issues exist (#7355/#7644), but those concerned arbitrary-resolution interpolation, not this supplied-latents path.

Reproduction:

import torch
from diffusers import DDPMWuerstchenScheduler, StableCascadePriorPipeline, StableCascadeUNet

prior = StableCascadeUNet(
 conditioning_dim=8, block_out_channels=(8,), num_attention_heads=(-1,),
 down_num_layers_per_block=(1,), up_num_layers_per_block=(1,),
 down_blocks_repeat_mappers=(1,), up_blocks_repeat_mappers=(1,),
 block_types_per_layer=(("SDCascadeResBlock", "SDCascadeTimestepBlock"),),
 clip_text_pooled_in_channels=8, clip_image_in_channels=8,
)
pipe = StableCascadePriorPipeline(None, None, prior, DDPMWuerstchenScheduler())
latents = torch.randn(1, prior.config.in_channels, 1, 1, dtype=torch.float32)

out = pipe.prepare_latents(1, 42, 42, 1, torch.bfloat16, torch.device("cpu"), None, latents, pipe.scheduler)
print(out.dtype) # torch.float32, expected torch.bfloat16

Relevant precedent:

diffusers/src/diffusers/pipelines/flux/pipeline_flux.py

Lines 615 to 617 in 0f1abc4

	if latents is not None:
	latent_image_ids = self._prepare_latent_image_ids(batch_size, height // 2, width // 2, device, dtype)
	return latents.to(device=device, dtype=dtype), latent_image_ids

Suggested fix:

latents = latents.to(device=device, dtype=dtype)

Issue 6: StableCascadePriorPipeline.timesteps is public but ignored

Affected code:

diffusers/src/diffusers/pipelines/stable_cascade/pipeline_stable_cascade_prior.py

Line 384 in 0f1abc4

timesteps: list[float] = None,

diffusers/src/diffusers/pipelines/stable_cascade/pipeline_stable_cascade_prior.py

Lines 558 to 560 in 0f1abc4

	# 4. Prepare and set timesteps
	self.scheduler.set_timesteps(num_inference_steps, device=device)
	timesteps = self.scheduler.timesteps

diffusers/src/diffusers/pipelines/stable_cascade/pipeline_stable_cascade_combined.py

Lines 222 to 229 in 0f1abc4

	prior_num_inference_steps (`int | dict[float, int]`, *optional*, defaults to 60):
	The number of prior denoising steps. More denoising steps usually lead to a higher quality image at the
	expense of slower inference. For more specific timestep spacing, you can pass customized
	`prior_timesteps`
	num_inference_steps (`int`, *optional*, defaults to 12):
	The number of decoder denoising steps. More denoising steps usually lead to a higher quality image at
	the expense of slower inference. For more specific timestep spacing, you can pass customized
	`timesteps`

Problem:
The prior pipeline accepts timesteps, and the combined docstring advertises customized prior_timesteps/timesteps, but the prior always calls self.scheduler.set_timesteps(num_inference_steps, device=device).

Impact:
Users cannot control the prior schedule despite the public API suggesting they can.

Reproduction:

import inspect
from diffusers import StableCascadePriorPipeline

src = inspect.getsource(StableCascadePriorPipeline.__call__)
print("timesteps parameter exists:", "timesteps: list[float]" in src)
print("passed to scheduler:", "timesteps=timesteps" in src)

Relevant precedent:

diffusers/src/diffusers/schedulers/scheduling_ddpm_wuerstchen.py

Lines 141 to 160 in 0f1abc4

	def set_timesteps(
	self,
	num_inference_steps: int = None,
	timesteps: list[int] | None = None,
	device: str | torch.device = None,
	):
	"""
	Sets the discrete timesteps used for the diffusion chain. Supporting function to be run before inference.
	Args:
	num_inference_steps (`dict[float, int]`):
	the number of diffusion steps used when generating samples with a pre-trained model. If passed, then
	`timesteps` must be `None`.
	device (`str` or `torch.device`, optional):
	the device to which the timesteps are moved to. {2 / 3: 20, 0.0: 10}
	"""
	if timesteps is None:
	timesteps = torch.linspace(1.0, 0.0, num_inference_steps + 1, device=device)
	if not isinstance(timesteps, torch.Tensor):
	timesteps = torch.Tensor(timesteps).to(device)

Suggested fix:

self.scheduler.set_timesteps(num_inference_steps, timesteps=timesteps, device=device)

Also either add matching decoder/combined args or remove the combined docstring claims.

Issue 7: Combined xFormers enable only reaches the decoder

Affected code:

diffusers/src/diffusers/pipelines/stable_cascade/pipeline_stable_cascade_combined.py

Lines 127 to 128 in 0f1abc4

	def enable_xformers_memory_efficient_attention(self, attention_op: Callable | None = None):
	self.decoder_pipe.enable_xformers_memory_efficient_attention(attention_op)

Problem:
StableCascadeCombinedPipeline.enable_xformers_memory_efficient_attention() delegates only to decoder_pipe, leaving the prior unchanged.

Impact:
Users enabling xFormers on the combined pipeline do not get memory-efficient attention for the prior stage.

Reproduction:

from unittest.mock import Mock
from diffusers import StableCascadeCombinedPipeline

pipe = StableCascadeCombinedPipeline.__new__(StableCascadeCombinedPipeline)
pipe.prior_pipe = Mock()
pipe.decoder_pipe = Mock()

pipe.enable_xformers_memory_efficient_attention()
print(pipe.prior_pipe.enable_xformers_memory_efficient_attention.call_count) # 0
print(pipe.decoder_pipe.enable_xformers_memory_efficient_attention.call_count) # 1

Relevant precedent:
The prior and decoder both contain StableCascadeUNet attention modules and both support recursive xFormers enabling through ModelMixin.

Suggested fix:

def enable_xformers_memory_efficient_attention(self, attention_op: Callable | None = None):
 self.prior_pipe.enable_xformers_memory_efficient_attention(attention_op)
 self.decoder_pipe.enable_xformers_memory_efficient_attention(attention_op)

Issue 8: Test coverage misses combined slow coverage and dedicated model fast tests

Affected code:

diffusers/tests/pipelines/stable_cascade/test_stable_cascade_combined.py

Lines 33 to 50 in 0f1abc4

	class StableCascadeCombinedPipelineFastTests(PipelineTesterMixin, unittest.TestCase):
	pipeline_class = StableCascadeCombinedPipeline
	params = ["prompt"]
	batch_params = ["prompt", "negative_prompt"]
	required_optional_params = [
	"generator",
	"height",
	"width",
	"latents",
	"prior_guidance_scale",
	"decoder_guidance_scale",
	"negative_prompt",
	"num_inference_steps",
	"return_dict",
	"prior_num_inference_steps",
	"output_type",
	]
	test_xformers_attention = True

diffusers/tests/pipelines/stable_cascade/test_stable_cascade_combined.py

Lines 242 to 244 in 0f1abc4

	@unittest.skip(reason="no callback test for combined pipeline")
	def test_callback_inputs(self):
	super().test_callback_inputs()

diffusers/tests/single_file/test_model_sd_cascade_unet_single_file.py

Lines 31 to 39 in 0f1abc4

	logger = logging.get_logger(__name__)
	enable_full_determinism()
	@slow
	@require_torch_accelerator
	class StableCascadeUNetSingleFileTest:

Problem:
Prior and decoder have slow integration tests, but the combined pipeline has no @slow test. StableCascadeUNet also lacks a dedicated fast tests/models/... test; it is mostly covered indirectly and by slow single-file config checks.

Impact:
The issues above are not covered by the current fast/slow matrix, especially direct model input-shape behavior and combined pipeline delegation behavior.

Reproduction:

from pathlib import Path

print("model fast tests:", list(Path("tests/models").glob("**/*stable*cascade*.py")))
for path in sorted(Path("tests/pipelines/stable_cascade").glob("test_*.py")):
 print(path.name, "@slow" in path.read_text())

Relevant precedent:
Most active model families have dedicated ModelTesterMixin coverage for forward, save/load, dtype, gradient checkpointing, and attention/offload behavior.

Suggested fix:
Add:

# tests/models/unets/test_models_unet_stable_cascade.py
class StableCascadeUNetTests(ModelTesterMixin, unittest.TestCase):
 model_class = StableCascadeUNet

and a @slow combined pipeline integration test that loads stabilityai/stable-cascade and exercises the full prior+decoder path.

Issue 9: Pipeline docstring examples are not runnable

Affected code:

diffusers/src/diffusers/pipelines/stable_cascade/pipeline_stable_cascade_prior.py

Lines 43 to 55 in 0f1abc4

	EXAMPLE_DOC_STRING = """
	Examples:
	```py
	>>> import torch
	>>> from diffusers import StableCascadePriorPipeline
	>>> prior_pipe = StableCascadePriorPipeline.from_pretrained(
	... "stabilityai/stable-cascade-prior", torch_dtype=torch.bfloat16
	... ).to("cuda")
	>>> prompt = "an image of a shiba inu, donning a spacesuit and helmet"
	>>> prior_output = pipe(prompt)
	```

diffusers/src/diffusers/pipelines/stable_cascade/pipeline_stable_cascade.py

Lines 38 to 54 in 0f1abc4

	EXAMPLE_DOC_STRING = """
	Examples:
	```py
	>>> import torch
	>>> from diffusers import StableCascadePriorPipeline, StableCascadeDecoderPipeline
	>>> prior_pipe = StableCascadePriorPipeline.from_pretrained(
	... "stabilityai/stable-cascade-prior", torch_dtype=torch.bfloat16
	... ).to("cuda")
	>>> gen_pipe = StableCascadeDecoderPipeline.from_pretrain(
	... "stabilityai/stable-cascade", torch_dtype=torch.float16
	... ).to("cuda")
	>>> prompt = "an image of a shiba inu, donning a spacesuit and helmet"
	>>> prior_output = pipe(prompt)
	>>> images = gen_pipe(prior_output.image_embeddings, prompt=prompt)
	```

Problem:
The prior example assigns prior_pipe but calls pipe(prompt). The decoder example calls StableCascadeDecoderPipeline.from_pretrain instead of from_pretrained and also calls pipe(prompt).

Impact:
Autodoc examples copied by users fail immediately.

Reproduction:

from pathlib import Path

for path in [
 Path("src/diffusers/pipelines/stable_cascade/pipeline_stable_cascade_prior.py"),
 Path("src/diffusers/pipelines/stable_cascade/pipeline_stable_cascade.py"),
]:
 text = path.read_text()
 print(path.name, "from_pretrain(" in text, "prior_output = pipe(prompt)" in text)

Relevant precedent:
The docs page docs/source/en/api/pipelines/stable_cascade.md uses the correct top-level imports and from_pretrained.

Suggested fix:

prior_output = prior_pipe(prompt)
gen_pipe = StableCascadeDecoderPipeline.from_pretrained(...)