Buckets:

hf-doc-build
/

doc

Files
xet
hf-doc-build/doc / diffusers /main /es /api /pipelines /stable_cascade.md
mishig
3 days ago
preview code
download
raw
40.3 kB
# Stable Cascade

Este modelo se basa en la arquitectura [Würstchen](https://openreview.net/forum?id=gU58d5QeGv) y su principal diferencia con otros modelos como Stable Diffusion es que opera en un espacio latente mucho más pequeño. ¿Por qué es importante? Cuanto más pequeño sea el espacio latente, más **rápido** se puede ejecutar la inferencia y más **barato** se vuelve el entrenamiento. ¿Qué tan pequeño es el espacio latente? Stable Diffusion utiliza un factor de compresión de 8, lo que resulta en que una imagen de 1024x1024 se codifique a 128x128. Stable Cascade logra un factor de compresión de 42, lo que significa que es posible codificar una imagen de 1024x1024 a 24x24, manteniendo reconstrucciones nítidas. El modelo condicional de texto se entrena luego en el espacio latente altamente comprimido. Versiones anteriores de esta arquitectura lograron una reducción de costos del 16x en comparación con Stable Diffusion 1.5.

Por lo tanto, este tipo de modelo es adecuado para usos donde la eficiencia es importante. Además, todas las extensiones conocidas, como finetuning, LoRA, ControlNet, IP-Adapter, LCM, etc., también son posibles con este método.

El código original se puede encontrar en [Stability-AI/StableCascade](https://github.com/Stability-AI/StableCascade).

## Resumen del modelo
Stable Cascade consta de tres modelos: Stage A, Stage B y Stage C, que representan una cascada para generar imágenes, de ahí el nombre "Stable Cascade".

Stage A & B se utilizan para comprimir imágenes, de manera similar a lo que hace el VAE en Stable Diffusion. Sin embargo, con esta configuración se puede lograr una compresión mucho mayor de las imágenes. Mientras que los modelos de Stable Diffusion utilizan un factor de compresión espacial de 8, codificando una imagen de resolución 1024 x 1024 a 128 x 128, Stable Cascade logra un factor de compresión de 42. Esto codifica una imagen de 1024 x 1024 a 24 x 24, al tiempo que permite decodificar la imagen con precisión. Esto conlleva el gran beneficio de un entrenamiento y una inferencia más económicos. Además, Stage C se encarga de generar los pequeños latentes de 24 x 24 a partir de un prompt de texto.

El modelo Stage C opera sobre los latentes pequeños de 24 x 24 y desruidiza los latentes condicionados a los prompts de texto. El modelo también es el componente más grande en la pipeline Cascade y está diseñado para usarse con `StableCascadePriorPipeline`

Los modelos Stage B y Stage A se utilizan con `StableCascadeDecoderPipeline` y son responsables de generar la imagen final a partir de los latentes pequeños de 24 x 24.

> [!WARNING]
> Existen algunas restricciones sobre los tipos de datos que se pueden usar con los modelos Stable Cascade. Los puntos de control oficiales para `StableCascadePriorPipeline` no admiten el tipo de datos `torch.float16`. Utilice `torch.bfloat16` en su lugar.
>
> Para usar el tipo de datos `torch.bfloat16` con `StableCascadeDecoderPipeline`, es necesario tener instalado PyTorch 2.2.0 o una versión superior. Esto también significa que el uso de `StableCascadeCombinedPipeline` con `torch.bfloat16` requiere PyTorch 2.2.0 o superior, ya que llama internamente a `StableCascadeDecoderPipeline`.
>
> Si no es posible instalar PyTorch 2.2.0 o superior en su entorno, se puede utilizar `StableCascadeDecoderPipeline` de forma independiente con el tipo de datos `torch.float16`. Puede descargar los pesos de la variante de precisión completa o `bf16` para el pipeline y convertir los pesos a `torch.float16`.

## Ejemplo de uso

```python
import torch
from diffusers import StableCascadeDecoderPipeline, StableCascadePriorPipeline
prompt = "an image of a shiba inu, donning a spacesuit and helmet"
negative_prompt = ""
prior = StableCascadePriorPipeline.from_pretrained("stabilityai/stable-cascade-prior", variant="bf16", dtype=torch.bfloat16)
decoder = StableCascadeDecoderPipeline.from_pretrained("stabilityai/stable-cascade", variant="bf16", dtype=torch.float16)
prior.enable_model_cpu_offload()
prior_output = prior(
    prompt=prompt,
    height=1024,
    width=1024,
    negative_prompt=negative_prompt,
    guidance_scale=4.0,
    num_images_per_prompt=1,
    num_inference_steps=20
)
decoder.enable_model_cpu_offload()
decoder_output = decoder(
    image_embeddings=prior_output.image_embeddings.to(torch.float16),
    prompt=prompt,
    negative_prompt=negative_prompt,
    guidance_scale=0.0,
    output_type="pil",
    num_inference_steps=10
).images[0]
decoder_output.save("cascade.png")
```

## Uso de las versiones Lite de los modelos de la Etapa B y la Etapa C

```python
import torch
from diffusers import (
    StableCascadeDecoderPipeline,
    StableCascadePriorPipeline,
    StableCascadeUNet,
)
prompt = "an image of a shiba inu, donning a spacesuit and helmet"
negative_prompt = ""
prior_unet = StableCascadeUNet.from_pretrained("stabilityai/stable-cascade-prior", subfolder="prior_lite")
decoder_unet = StableCascadeUNet.from_pretrained("stabilityai/stable-cascade", subfolder="decoder_lite")
prior = StableCascadePriorPipeline.from_pretrained("stabilityai/stable-cascade-prior", prior=prior_unet)
decoder = StableCascadeDecoderPipeline.from_pretrained("stabilityai/stable-cascade", decoder=decoder_unet)
prior.enable_model_cpu_offload()
prior_output = prior(
    prompt=prompt,
    height=1024,
    width=1024,
    negative_prompt=negative_prompt,
    guidance_scale=4.0,
    num_images_per_prompt=1,
    num_inference_steps=20
)
decoder.enable_model_cpu_offload()
decoder_output = decoder(
    image_embeddings=prior_output.image_embeddings,
    prompt=prompt,
    negative_prompt=negative_prompt,
    guidance_scale=0.0,
    output_type="pil",
    num_inference_steps=10
).images[0]
decoder_output.save("cascade.png")
```

## Carga de puntos de control originales con `from_single_file`

La carga de puntos de control en el formato original se admite mediante el método `from_single_file` en StableCascadeUNet.

```python
import torch
from diffusers import (
    StableCascadeDecoderPipeline,
    StableCascadePriorPipeline,
    StableCascadeUNet,
)
prompt = "an image of a shiba inu, donning a spacesuit and helmet"
negative_prompt = ""
prior_unet = StableCascadeUNet.from_single_file(
    "https://huggingface.co/stabilityai/stable-cascade/resolve/main/stage_c_bf16.safetensors",
    dtype=torch.bfloat16
)
decoder_unet = StableCascadeUNet.from_single_file(
    "https://huggingface.co/stabilityai/stable-cascade/blob/main/stage_b_bf16.safetensors",
    dtype=torch.bfloat16
)
prior = StableCascadePriorPipeline.from_pretrained("stabilityai/stable-cascade-prior", prior=prior_unet, dtype=torch.bfloat16)
decoder = StableCascadeDecoderPipeline.from_pretrained("stabilityai/stable-cascade", decoder=decoder_unet, dtype=torch.bfloat16)
prior.enable_model_cpu_offload()
prior_output = prior(
    prompt=prompt,
    height=1024,
    width=1024,
    negative_prompt=negative_prompt,
    guidance_scale=4.0,
    num_images_per_prompt=1,
    num_inference_steps=20
)
decoder.enable_model_cpu_offload()
decoder_output = decoder(
    image_embeddings=prior_output.image_embeddings,
    prompt=prompt,
    negative_prompt=negative_prompt,
    guidance_scale=0.0,
    output_type="pil",
    num_inference_steps=10
).images[0]
decoder_output.save("cascade-single-file.png")
```

## Usos

### Uso directo

El modelo está destinado a fines de investigación por ahora. Las posibles áreas y tareas de investigación incluyen

- Investigación sobre modelos generativos.
- Despliegue seguro de modelos con el potencial de generar contenido dañino.
- Explorar y comprender las limitaciones y los sesgos de los modelos generativos.
- Generación de obras de arte y uso en el diseño y otros procesos artísticos.
- Aplicaciones en herramientas educativas o creativas.

Los usos excluidos se describen a continuación.

### Uso fuera de alcance

El modelo no fue entrenado para ser una representación factual o verdadera de personas o eventos, y por lo tanto, usar el modelo para generar dicho contenido está fuera del alcance de las capacidades de este modelo. El modelo no debe usarse de ninguna manera que viole la [Política de Uso Aceptable](https://stability.ai/use-policy) de Stability AI.

## Limitaciones y sesgo

### Limitaciones
- Es posible que las caras y las personas en general no se generen correctamente.
- La parte de auto-codificación del modelo es con pérdida.

## StableCascadeCombinedPipeline[[diffusers.StableCascadeCombinedPipeline]]

#### diffusers.StableCascadeCombinedPipeline[[diffusers.StableCascadeCombinedPipeline]]

```python
diffusers.StableCascadeCombinedPipeline(tokenizer: CLIPTokenizer, text_encoder: CLIPTextModelWithProjection, decoder: StableCascadeUNet, scheduler: DDPMWuerstchenScheduler, vqgan: PaellaVQModel, prior_prior: StableCascadeUNet, prior_text_encoder: CLIPTextModelWithProjection, prior_tokenizer: CLIPTokenizer, prior_scheduler: DDPMWuerstchenScheduler, prior_feature_extractor: transformers.models.clip.image_processing_pil_clip.CLIPImageProcessorPil | None = None, prior_image_encoder: transformers.models.clip.modeling_clip.CLIPVisionModelWithProjection | None = None)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/stable_cascade/pipeline_stable_cascade_combined.py#L46)

**Parámetros:**

tokenizer (`CLIPTokenizer`) : El tokenizador decodificador que se utilizará para las entradas de texto.

text_encoder (`CLIPTextModelWithProjection`) : El codificador de texto del decodificador que se utilizará para las entradas de texto.
decoder (`StableCascadeUNet`) : El modelo decodificador que se utilizará para el pipeline de generación de imágenes del decodificador.
scheduler (`DDPMWuerstchenScheduler`) : El programador que se utilizará para el pipeline de generación de imágenes del decodificador.
vqgan (`PaellaVQModel`) : El modelo VQGAN que se utilizará para el pipeline de generación de imágenes del decodificador.
prior_prior (`StableCascadeUNet`) : El modelo previo que se utilizará para el pipeline previo.

prior_text_encoder (`CLIPTextModelWithProjection`) : El codificador de texto anterior que se utilizará para las entradas de texto.

prior_tokenizer (`CLIPTokenizer`) : El tokenizador anterior que se utilizará para las entradas de texto.
prior_scheduler (`DDPMWuerstchenScheduler`) : El programador que se utilizará para el pipeline previo.

prior_feature_extractor ([CLIPImageProcessor](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPImageProcessor)) : Modelo que extrae características de las imágenes generadas para usarlas como entradas del `image_encoder`.

prior_image_encoder (`CLIPVisionModelWithProjection`) : Codificador de imágenes CLIP congelado ([clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14)).

Pipeline combinado para la generación de texto a imagen usando Stable Cascade.

Este modelo hereda de [DiffusionPipeline](/docs/diffusers/main/es/api/pipelines/overview#diffusers.DiffusionPipeline). Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos los pipelines (como la descarga o el guardado, la ejecución en un dispositivo específico, etc.)

#### __call__[[diffusers.StableCascadeCombinedPipeline.__call__]]

```python
__call__(prompt: str | list[str] | None = None, images: typing.Union[torch.Tensor, list[torch.Tensor], PIL.Image.Image, list[PIL.Image.Image]] = None, height: int = 512, width: int = 512, prior_num_inference_steps: int = 60, prior_guidance_scale: float = 4.0, num_inference_steps: int = 12, decoder_guidance_scale: float = 0.0, negative_prompt: str | list[str] | None = None, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_embeds_pooled: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds_pooled: typing.Optional[torch.Tensor] = None, num_images_per_prompt: int = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', return_dict: bool = True, prior_callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, prior_callback_on_step_end_tensor_inputs: list[str] = ['latents'], callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'])
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/stable_cascade/pipeline_stable_cascade_combined.py#L159)

**Parámetros:**

prompt (`str` o `list[str]`) : El prompt o los prompts para guiar la generación de imágenes del prior y el decodificador.

images (`torch.Tensor`, `PIL.Image.Image`, `list[torch.Tensor]`, `list[PIL.Image.Image]`, *opcional*) : Las imágenes para guiar la generación de imágenes del prior.

negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts que no deben guiar la generación de la imagen. Se ignora cuando no se usa guía (es decir, se ignora si `guidance_scale` es menor que `1`).

prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pregenerados para el prior. Se pueden usar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporciona, los embeddings de texto se generarán a partir del argumento de entrada `prompt`.
prompt_embeds_pooled (`torch.Tensor`, *opcional*) : Embeddings de texto pregenerados para el prior. Se pueden usar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporciona, los embeddings de texto se generarán a partir del argumento de entrada `prompt`.
negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados para el prior. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporcionan, negative_prompt_embeds se generará a partir del argumento de entrada `negative_prompt`.

negative_prompt_embeds_pooled (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados para el prior. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporcionan, negative_prompt_embeds se generará a partir del argumento de entrada `negative_prompt`.

num_images_per_prompt (`int`, *opcional*, valor predeterminado 1) : El número de imágenes a generar por indicación.
height (`int`, *opcional*, valor predeterminado 512) : La altura en píxeles de la imagen generada.
width (`int`, *opcional*, valor predeterminado 512) : El ancho en píxeles de la imagen generada.
prior_guidance_scale (`float`, *opcional*, valor predeterminado 4.0) : Escala de guía definida en [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `prior_guidance_scale` se define como `w` de la ecuación 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). La escala de guía se habilita estableciendo `prior_guidance_scale > 1`. Una escala de guía más alta fomenta la generación de imágenes estrechamente vinculadas al `prompt` de texto, generalmente a costa de una menor calidad de imagen.
prior_num_inference_steps (`int | dict[float, int]`, *opcional*, valor predeterminado 60) : El número de pasos previos de desruido. Más pasos de desruido suelen conducir a una imagen de mayor calidad a costa de una inferencia más lenta. Para un espaciado de pasos de tiempo más específico, puede pasar `prior_timesteps` personalizados

num_inference_steps (`int`, *opcional*, valor predeterminado 12) : El número de pasos de desruido del decodificador. Más pasos de desruido suelen conducir a una imagen de mayor calidad a costa de una inferencia más lenta. Para un espaciado de pasos de tiempo más específico, puedes pasar `timesteps` personalizados

decoder_guidance_scale (`float`, *opcional*, valor predeterminado 0.0) : Escala de orientación definida en [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` se define como `w` de la ecuación 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). La escala de orientación se habilita estableciendo `guidance_scale > 1`. Una escala de orientación más alta fomenta la generación de imágenes estrechamente vinculadas al `prompt` de texto, generalmente a costa de una menor calidad de imagen.

generator (`torch.Generator` o `list[torch.Generator]`, *opcional*) : Uno o una lista de [generadores de torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) para hacer la generación determinista.

latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pregenerados, muestreados de una distribución gaussiana, que se utilizarán como entradas para la generación de imágenes. Se pueden usar para ajustar la misma generación con diferentes prompts. Si no se proporcionan, se generará un tensor de latentes mediante muestreo usando el `generator` aleatorio suministrado.

output_type (`str`, *opcional*, valor predeterminado `"pil"`) : El formato de salida de la imagen generada. Elija entre: `"pil"` (`PIL.Image.Image`), `"np"` (`np.array`) o `"pt"` (`torch.Tensor`).
return_dict (`bool`, *opcional*, por defecto `True`) : Si se debe devolver un [ImagePipelineOutput](/docs/diffusers/main/es/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) en lugar de una tupla simple.

prior_callback_on_step_end (`Callable`, *opcional*) : Una función que se llama al final de cada paso de desruido durante la inferencia. La función se llama con los siguientes argumentos: `prior_callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`.

prior_callback_on_step_end_tensor_inputs (`list`, *opcional*) : La lista de entradas de tensor para la función `prior_callback_on_step_end`. Los tensores especificados en la lista se pasarán como argumento `callback_kwargs`. Solo podrá incluir variables enumeradas en el atributo `._callback_tensor_inputs` de su clase de pipeline.

callback_on_step_end (`Callable`, *opcional*) : Una función que se llama al final de cada paso de desruido durante la inferencia. La función se llama con los siguientes argumentos: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` incluirá una lista de todos los tensores especificados por `callback_on_step_end_tensor_inputs`.
callback_on_step_end_tensor_inputs (`list`, *opcional*) : La lista de entradas de tensor para la función `callback_on_step_end`. Los tensores especificados en la lista se pasarán como argumento `callback_kwargs`. Solo podrá incluir variables enumeradas en el atributo `._callback_tensor_inputs` de su clase de pipeline.

**Devuelve:**

[ImagePipelineOutput](/docs/diffusers/main/es/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) o `tuple` [ImagePipelineOutput](/docs/diffusers/main/es/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) si `return_dict` es True, de lo contrario una `tuple`. Al devolver una tupla, el primer elemento es una lista con las imágenes generadas.

Función invocada al llamar a la pipeline para la generación.

Ejemplos:
```py
>>> import torch
>>> from diffusers import StableCascadeCombinedPipeline
>>> pipe = StableCascadeCombinedPipeline.from_pretrained(
...     "stabilityai/stable-cascade", variant="bf16", torch_dtype=torch.bfloat16
... )
>>> pipe.enable_model_cpu_offload()
>>> prompt = "an image of a shiba inu, donning a spacesuit and helmet"
>>> images = pipe(prompt=prompt)
```

#### enable_model_cpu_offload[[diffusers.StableCascadeCombinedPipeline.enable_model_cpu_offload]]

```python
enable_model_cpu_offload(gpu_id: int | None = None, device: typing.Union[torch.device, str] = None)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/stable_cascade/pipeline_stable_cascade_combined.py#L131)

Descarga todos los modelos a la CPU usando accelerate, reduciendo el uso de memoria con un bajo impacto en el rendimiento. En comparación con `enable_sequential_cpu_offload`, este método mueve un modelo completo a la GPU a la vez cuando se llama a su método `forward`, y el modelo permanece en la GPU hasta que se ejecute el siguiente modelo. El ahorro de memoria es menor que con `enable_sequential_cpu_offload`, pero el rendimiento es mucho mejor debido a la ejecución iterativa de `unet`.

#### enable_sequential_cpu_offload[[diffusers.StableCascadeCombinedPipeline.enable_sequential_cpu_offload]]

```python
enable_sequential_cpu_offload(gpu_id: int | None = None, device: typing.Union[torch.device, str] = None)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/stable_cascade/pipeline_stable_cascade_combined.py#L141)

Descarga todos los modelos (los state dicts de `unet`, `text_encoder`, `vae` y `safety checker`) a la CPU usando 🤗 Accelerate, reduciendo significativamente el uso de memoria. Los modelos se mueven a un `torch.device('meta')` y se cargan en una GPU solo cuando se llama al método `forward` de su submódulo específico. El descargado se realiza a nivel de submódulo. El ahorro de memoria es mayor que al usar `enable_model_cpu_offload`, pero el rendimiento es menor.

## StableCascadePriorPipeline[[diffusers.StableCascadePriorPipeline]]

#### diffusers.StableCascadePriorPipeline[[diffusers.StableCascadePriorPipeline]]

```python
diffusers.StableCascadePriorPipeline(tokenizer: CLIPTokenizer, text_encoder: CLIPTextModelWithProjection, prior: StableCascadeUNet, scheduler: DDPMWuerstchenScheduler, resolution_multiple: float = 42.67, feature_extractor: transformers.models.clip.image_processing_pil_clip.CLIPImageProcessorPil | None = None, image_encoder: transformers.models.clip.modeling_clip.CLIPVisionModelWithProjection | None = None)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/stable_cascade/pipeline_stable_cascade_prior.py#L80)

**Parámetros:**

prior (`StableCascadeUNet`) : El Stable Cascade previo para aproximar el embedding de imagen a partir del embedding de texto y/o imagen.

text_encoder (`CLIPTextModelWithProjection`) : Codificador de texto congelado ([laion/CLIP-ViT-bigG-14-laion2B-39B-b160k](https://huggingface.co/laion/CLIP-ViT-bigG-14-laion2B-39B-b160k)).
feature_extractor ([CLIPImageProcessor](https://huggingface.co/docs/transformers/main/en/model_doc/clip#transformers.CLIPImageProcessor)) : Modelo que extrae características de las imágenes generadas para usarlas como entradas del `image_encoder`.

image_encoder (`CLIPVisionModelWithProjection`) : Codificador de imágenes CLIP congelado ([clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14)).
tokenizer (`CLIPTokenizer`) : Tokenizador de la clase [CLIPTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer).
scheduler (`DDPMWuerstchenScheduler`) : Un programador para usar en combinación con `prior` para generar la incrustación de imagen.
resolution_multiple ('float', *opcional*, valor predeterminado 42.67) : Resolución predeterminada para varias imágenes generadas.

Pipeline para generar un prior de imagen para Stable Cascade.

Este modelo hereda de [DiffusionPipeline](/docs/diffusers/main/es/api/pipelines/overview#diffusers.DiffusionPipeline). Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos los pipelines (como la descarga o el guardado, la ejecución en un dispositivo específico, etc.)

#### __call__[[diffusers.StableCascadePriorPipeline.__call__]]

```python
__call__(prompt: str | list[str] | None = None, images: typing.Union[torch.Tensor, list[torch.Tensor], PIL.Image.Image, list[PIL.Image.Image]] = None, height: int = 1024, width: int = 1024, num_inference_steps: int = 20, timesteps: list[float] = None, guidance_scale: float = 4.0, negative_prompt: str | list[str] | None = None, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_embeds_pooled: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds_pooled: typing.Optional[torch.Tensor] = None, image_embeds: typing.Optional[torch.Tensor] = None, num_images_per_prompt: int | None = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pt', return_dict: bool = True, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'])
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/stable_cascade/pipeline_stable_cascade_prior.py#L375)

**Parámetros:**

prompt (`str` o `list[str]`) : El prompt o los prompts para guiar la generación de la imagen.

images (`torch.Tensor`, `PIL.Image.Image`, `list[torch.Tensor]` o `list[PIL.Image.Image]`, *opcional*) : Imagen(es) de referencia utilizada(s) para condicionar la generación previa. Cuando se proporciona, los embeddings de imagen se derivan de la imagen y se combinan con el prompt de texto.

height (`int`, *opcional*, valor predeterminado 1024) : La altura en píxeles de la imagen generada.

width (`int`, *opcional*, valor predeterminado 1024) : El ancho en píxeles de la imagen generada.

num_inference_steps (`int`, *opcional*, valor predeterminado 60) : El número de pasos de desruido. Más pasos de desruido suelen conducir a una imagen de mayor calidad a costa de una inferencia más lenta.

timesteps (`list[float]`, *opcional*) : Pasos de tiempo personalizados para usar en el proceso de desruido con programadores que admiten un argumento `timesteps` en su método `set_timesteps`. Si no se define, se usará el comportamiento predeterminado cuando se pase `num_inference_steps`. Debe estar en orden descendente.

guidance_scale (`float`, *opcional*, valor predeterminado 8.0) : Escala de orientación definida en [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `decoder_guidance_scale` se define como `w` de la ecuación 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). La escala de orientación se habilita estableciendo `decoder_guidance_scale > 1`. Una escala de orientación más alta fomenta la generación de imágenes estrechamente vinculadas al `prompt` de texto, generalmente a costa de una menor calidad de imagen.
negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts que no deben guiar la generación de la imagen. Se ignora cuando no se usa guía (es decir, se ignora si `decoder_guidance_scale` es menor que `1`).

prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto, *p. ej.* ponderación de prompts. Si no se proporcionan, los embeddings de texto se generarán a partir del argumento de entrada `prompt`.
prompt_embeds_pooled (`torch.Tensor`, *opcional*) : Embeddings de texto agrupados pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporcionan, los embeddings de texto agrupados se generarán a partir del argumento de entrada `prompt`.
negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporcionan, negative_prompt_embeds se generará a partir del argumento de entrada `negative_prompt`.

negative_prompt_embeds_pooled (`torch.Tensor`, *opcional*) : Embeddings de texto negativo ya generados. Se pueden usar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporciona, negative_prompt_embeds_pooled se generará a partir del argumento de entrada `negative_prompt`.

image_embeds (`torch.Tensor`, *opcional*) : Incrustaciones de imagen pregeneradas. Se pueden usar para ajustar fácilmente las entradas de imagen, *p. ej.* ponderación de prompts. Si no se proporcionan, las incrustaciones de imagen se generarán a partir del argumento de entrada `image` si este existe.
num_images_per_prompt (`int`, *opcional*, valor predeterminado 1) : El número de imágenes a generar por indicación.

generator (`torch.Generator` o `list[torch.Generator]`, *opcional*) : Uno o una lista de [generadores de torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) para hacer la generación determinista.

latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pregenerados, muestreados de una distribución gaussiana, que se utilizarán como entradas para la generación de imágenes. Se pueden usar para ajustar la misma generación con diferentes prompts. Si no se proporcionan, se generará un tensor de latentes mediante muestreo usando el `generator` aleatorio suministrado.

output_type (`str`, *opcional*, valor predeterminado `"pil"`) : El formato de salida de la imagen generada. Elija entre: `"pil"` (`PIL.Image.Image`), `"np"` (`np.array`) o `"pt"` (`torch.Tensor`).
return_dict (`bool`, *opcional*, por defecto `True`) : Si se debe devolver un [ImagePipelineOutput](/docs/diffusers/main/es/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) en lugar de una tupla simple.

callback_on_step_end (`Callable`, *opcional*) : Una función que se llama al final de cada paso de desruido durante la inferencia. La función se llama con los siguientes argumentos: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` incluirá una lista de todos los tensores especificados por `callback_on_step_end_tensor_inputs`.
callback_on_step_end_tensor_inputs (`list`, *opcional*) : La lista de entradas de tensor para la función `callback_on_step_end`. Los tensores especificados en la lista se pasarán como argumento `callback_kwargs`. Solo podrá incluir variables enumeradas en el atributo `._callback_tensor_inputs` de su clase de pipeline.

**Devuelve:**

`StableCascadePriorPipelineOutput` o `tuple` `StableCascadePriorPipelineOutput` si `return_dict` es True, de lo contrario una `tuple`. Al devolver una tupla, el primer elemento es una lista con los embeddings de imagen generados.

Función invocada al llamar a la pipeline para la generación.

Ejemplos:
```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)
```

## StableCascadePriorPipelineOutput[[diffusers.pipelines.stable_cascade.pipeline_stable_cascade_prior.StableCascadePriorPipelineOutput]]

#### diffusers.pipelines.stable_cascade.pipeline_stable_cascade_prior.StableCascadePriorPipelineOutput[[diffusers.pipelines.stable_cascade.pipeline_stable_cascade_prior.StableCascadePriorPipelineOutput]]

```python
diffusers.pipelines.stable_cascade.pipeline_stable_cascade_prior.StableCascadePriorPipelineOutput(image_embeddings: typing.Union[torch.Tensor, numpy.ndarray], prompt_embeds: typing.Union[torch.Tensor, numpy.ndarray], prompt_embeds_pooled: typing.Union[torch.Tensor, numpy.ndarray], negative_prompt_embeds: typing.Union[torch.Tensor, numpy.ndarray], negative_prompt_embeds_pooled: typing.Union[torch.Tensor, numpy.ndarray])
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/stable_cascade/pipeline_stable_cascade_prior.py#L60)

**Parámetros:**

image_embeddings (`torch.Tensor` o `np.ndarray`) : Embeddings de imagen previos para el prompt de texto
prompt_embeds (`torch.Tensor`) : Incrustaciones de texto para el prompt.

negative_prompt_embeds (`torch.Tensor`) : Embeddings de texto para el prompt negativo.

Clase de salida para WuerstchenPriorPipeline.

## StableCascadeDecoderPipeline[[diffusers.StableCascadeDecoderPipeline]]

#### diffusers.StableCascadeDecoderPipeline[[diffusers.StableCascadeDecoderPipeline]]

```python
diffusers.StableCascadeDecoderPipeline(decoder: StableCascadeUNet, tokenizer: CLIPTokenizer, text_encoder: CLIPTextModelWithProjection, scheduler: DDPMWuerstchenScheduler, vqgan: PaellaVQModel, latent_dim_scale: float = 10.67)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/stable_cascade/pipeline_stable_cascade.py#L60)

**Parámetros:**

tokenizer (`CLIPTokenizer`) : El tokenizador de CLIP.

text_encoder (`CLIPTextModelWithProjection`) : El codificador de texto de CLIP.
decoder (`StableCascadeUNet`) : La unet del decodificador de Stable Cascade.
vqgan (`PaellaVQModel`) : El modelo VQGAN.
scheduler (`DDPMWuerstchenScheduler`) : Un programador para usar en combinación con `prior` para generar la incrustación de imagen.
latent_dim_scale (float, `optional`, valor predeterminado 10.67) : Multiplicador para determinar el tamaño del espacio latente VQ a partir de los embeddings de imagen. Si los embeddings de imagen tienen height=24 y width=24, la forma del latente VQ debe ser height=int(24*10.67)=256 y width=int(24*10.67)=256 para coincidir con las condiciones de entrenamiento.
Pipeline para generar imágenes desde el modelo Stable Cascade.
Este modelo hereda de [DiffusionPipeline](/docs/diffusers/main/es/api/pipelines/overview#diffusers.DiffusionPipeline). Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos los pipelines (como la descarga o el guardado, la ejecución en un dispositivo específico, etc.)
#### __call__[[diffusers.StableCascadeDecoderPipeline.__call__]]
```python
__call__(image_embeddings: typing.Union[torch.Tensor, list[torch.Tensor]], prompt: str | list[str] = None, num_inference_steps: int = 10, guidance_scale: float = 0.0, negative_prompt: str | list[str] | None = None, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_embeds_pooled: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds_pooled: typing.Optional[torch.Tensor] = None, num_images_per_prompt: int = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', return_dict: bool = True, callback_on_step_end: typing.Optional[typing.Callable[[int, int], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'])
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/stable_cascade/pipeline_stable_cascade.py#L306)
**Parámetros:**
image_embeddings (`torch.Tensor` o `list[torch.Tensor]`) : Embeddings de imagen extraídos de una imagen o generados por un Prior Model.

prompt (`str` o `list[str]`) : El prompt o los prompts para guiar la generación de la imagen.

num_inference_steps (`int`, *opcional*, valor predeterminado 12) : El número de pasos de desruido. Más pasos de desruido suelen conducir a una imagen de mayor calidad a costa de una inferencia más lenta.

guidance_scale (`float`, *opcional*, valor predeterminado 0.0) : Escala de orientación definida en [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `decoder_guidance_scale` se define como `w` de la ecuación 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). La escala de orientación se habilita estableciendo `decoder_guidance_scale > 1`. Una escala de orientación más alta fomenta la generación de imágenes estrechamente vinculadas al `prompt` de texto, generalmente a costa de una menor calidad de imagen.
negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts que no deben guiar la generación de la imagen. Se ignora cuando no se usa guía (es decir, se ignora si `decoder_guidance_scale` es menor que `1`).

prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pregenerados. Se pueden usar para ajustar fácilmente las entradas de texto, *p. ej.* ponderación de prompts. Si no se proporcionan, los embeddings de texto se generarán a partir del argumento de entrada `prompt`.
prompt_embeds_pooled (`torch.Tensor`, *opcional*) : Embeddings de texto agrupados pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporcionan, los embeddings de texto agrupados se generarán a partir del argumento de entrada `prompt`.
negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativos pregenerados. Se pueden utilizar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporcionan, negative_prompt_embeds se generará a partir del argumento de entrada `negative_prompt`.

negative_prompt_embeds_pooled (`torch.Tensor`, *opcional*) : Embeddings de texto negativo ya generados. Se pueden usar para ajustar fácilmente las entradas de texto, *p. ej.* el ponderado de prompts. Si no se proporciona, negative_prompt_embeds_pooled se generará a partir del argumento de entrada `negative_prompt`.

num_images_per_prompt (`int`, *opcional*, valor predeterminado 1) : El número de imágenes a generar por indicación.
generator (`torch.Generator` o `list[torch.Generator]`, *opcional*) : Uno o una lista de [generadores de torch](https://pytorch.org/docs/stable/generated/torch.Generator.html) para hacer la generación determinista.
latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pregenerados, muestreados de una distribución gaussiana, que se utilizarán como entradas para la generación de imágenes. Se pueden usar para ajustar la misma generación con diferentes prompts. Si no se proporcionan, se generará un tensor de latentes mediante muestreo usando el `generator` aleatorio suministrado.
output_type (`str`, *opcional*, valor predeterminado `"pil"`) : El formato de salida de la imagen generada. Elija entre: `"pil"` (`PIL.Image.Image`), `"np"` (`np.array`) o `"pt"` (`torch.Tensor`).

return_dict (`bool`, *opcional*, por defecto `True`) : Si se debe devolver un [ImagePipelineOutput](/docs/diffusers/main/es/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) en lugar de una tupla simple.
callback_on_step_end (`Callable`, *opcional*) : Una función que se llama al final de cada paso de desruido durante la inferencia. La función se llama con los siguientes argumentos: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int, callback_kwargs: Dict)`. `callback_kwargs` incluirá una lista de todos los tensores especificados por `callback_on_step_end_tensor_inputs`.

callback_on_step_end_tensor_inputs (`list`, *opcional*) : La lista de entradas de tensor para la función `callback_on_step_end`. Los tensores especificados en la lista se pasarán como argumento `callback_kwargs`. Solo podrá incluir variables enumeradas en el atributo `._callback_tensor_inputs` de su clase de pipeline.

**Devuelve:**

[ImagePipelineOutput](/docs/diffusers/main/es/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) o `tuple` [ImagePipelineOutput](/docs/diffusers/main/es/api/pipelines/consistency_models#diffusers.ImagePipelineOutput) si `return_dict` es True, de lo contrario una `tuple`. Al devolver una tupla, el primer elemento es una lista con los embeddings de imagen generados.

Función invocada al llamar a la pipeline para la generación.

Ejemplos:
```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)
```
Xet Storage Details

Size:: 40.3 kB
Xet hash:: 1ee03d46ce43344a1d602be2000e284e1101072f254401bc8dd22c70f170cb3c
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.