# Qwen-Image 2.1

Qwen-Image 2.1 codifica el prompt y las imágenes de condición junto con un modelo Qwen3-VL y luego desruidifica la imagen objetivo con un transformer de flujo único y causal por bloques. Consulte [`QwenImage21Transformer2DModel`](../models/qwenimage21_transformer2d) para la atención causal por bloques, los procesadores de atención y `causal_condition`.

Los valores predeterminados son los que recomienda Qwen: 40 pasos y sin guía. Pasa un `negative_prompt` junto con `true_cfg_scale > 1` para activar la guía libre de clasificador, lo que duplica el trabajo por paso.

```python
import torch
from diffusers import QwenImage21Pipeline

pipe = QwenImage21Pipeline.from_pretrained("Qwen/Qwen-Image-2.1", dtype=torch.bfloat16).to("cuda")

# Text-to-image
image = pipe("A capybara wearing a wizard hat, oil painting").images[0]
image.save("t2i.png")

# Image-conditioned editing
edited = pipe("Move it to a snowy mountain top", image=image).images[0]
edited.save("edit.png")
```

## Imágenes de múltiples condiciones

Pase una lista a `image` y cada entrada se convierte en su propio bloque en la secuencia conjunta: el codificador de Qwen3-VL las ve como contexto visual y el VAE aporta sus tokens latentes. La atención causal por bloques mantiene cada bloque internamente bidireccional mientras permite que los bloques posteriores y la imagen objetivo presten atención a los anteriores, por lo que el orden en que las pase es el orden en que el modelo las lee.

```python
edited = pipe("Put the flowers from the first image into the second scene", image=[flowers, scene]).images[0]
```

## Atención más rápida con flex_attention

El `QwenImage21AttnProcessor` predeterminado ejecuta el prefill causal por bloques como una sola llamada de atención por segmento de prefijo. No requiere compilación y funciona en cualquier compilación de PyTorch. `QwenImage21FlexAttnProcessor` expresa la misma máscara como una única llamada a `flex_attention`, lo cual es más rápido una vez que el modelo está **_compilado_**.

> [!TIP]
> Compila el modelo al cambiar al procesador flex. Un `flex_attention` sin compilar materializa la matriz completa de puntuaciones de atención en fp32, lo cual es mucho más lento y agota la memoria a alta resolución.

```python
from diffusers.models.transformers.transformer_qwenimage21 import QwenImage21FlexAttnProcessor

pipe.transformer.set_attn_processor(QwenImage21FlexAttnProcessor())
pipe.transformer.compile()
```

## Carga de puntos de control de un solo archivo

```python
import torch
from diffusers import QwenImage21Pipeline, QwenImage21Transformer2DModel

transformer = QwenImage21Transformer2DModel.from_single_file(
    "https://huggingface.co/Comfy-Org/Qwen-Image-2.1/blob/main/diffusion_models/qwen_image_2.1_bf16.safetensors",
    dtype=torch.bfloat16,
)
pipe = QwenImage21Pipeline.from_pretrained("Qwen/Qwen-Image-2.1", transformer=transformer, dtype=torch.bfloat16).to(
    "cuda"
)
```

## Sigmas de muestreo

Los autores de modelos pueden configurar una cuadrícula de muestreo predeterminada con `sample_sigmas` en la configuración de la pipeline. Al cargar un checkpoint publicado, su cuadrícula predeterminada y la configuración del scheduler se restauran automáticamente.

Para experimentar con una cuadrícula diferente en tiempo de ejecución, pase `sigmas` a la llamada de la pipeline:

```python
# Use the checkpoint's default sampling grid.
image = pipe(prompt).images[0]

# Override the default grid for this call.
image = pipe(prompt, sigmas=[1.0, 0.8, 0.5, 0.2]).images[0]
```

La cuadrícula personalizada anterior ilustra la API; la calidad de la generación depende del checkpoint y de la cuadrícula. Las listas de Sigma excluyen el sigma terminal, que el scheduler añade. Los `sigmas` explícitos reemplazan a los `sample_sigmas` configurados, y cualquiera de las dos listas determina el número de pasos en lugar de `num_inference_steps`. Si no se proporciona ninguna, el pipeline utiliza `num_inference_steps` para generar el schedule. El scheduler aplica su procesamiento configurado a cualquiera de las dos cuadrículas.

## Modular

Qwen-Image 2.1 también está disponible como [pipeline modular](../../modular_diffusers/overview). Los mismos bloques ejecutan la generación de texto a imagen y la generación condicionada por imagen: pase `image` para condicionar en una o más imágenes. La guía libre de clasificador se configura a través del componente `guider` en lugar de un argumento de llamada `true_cfg_scale`, y la caché KV de prefijo está activada por defecto (`use_kv_cache=False` la desactiva).

```python
import torch
from diffusers import ClassifierFreeGuidance, ModularPipeline

pipe = ModularPipeline.from_pretrained("Qwen/Qwen-Image-2.1")
pipe.load_components(dtype=torch.bfloat16)
pipe.to("cuda")

image = pipe(prompt="A capybara wearing a wizard hat, oil painting").images[0]

# Turn classifier-free guidance on for an edit.
pipe.update_components(guider=ClassifierFreeGuidance(guidance_scale=4.0))
edited = pipe(prompt="Move it to a snowy mountain top", negative_prompt="blurry", image=image).images[0]
```

El checkpoint de Turbo se corresponde con sus propios bloques ([QwenImage21TurboAutoBlocks](/docs/diffusers/main/es/api/pipelines/qwenimage21#diffusers.QwenImage21TurboAutoBlocks)): se ejecuta sin un `guider`, no toma un `negative_prompt` y muestrea la cuadrícula de sigma que incluye. `ModularPipeline.from_pretrained` selecciona los bloques de Turbo a partir de la entrada `sample_sigmas` en la configuración del checkpoint, por lo que no es necesario configurar nada:

```python
import torch
from diffusers import ModularPipeline

pipe = ModularPipeline.from_pretrained("Qwen/Qwen-Image-2.1-Turbo")
pipe.load_components(dtype=torch.bfloat16)
pipe.to("cuda")

image = pipe(prompt="A capybara wearing a wizard hat, oil painting").images[0]
```

## QwenImage21Pipeline[[diffusers.QwenImage21Pipeline]]

#### diffusers.QwenImage21Pipeline[[diffusers.QwenImage21Pipeline]]

```python
diffusers.QwenImage21Pipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKLQwenImage21, text_encoder: Qwen3VLForConditionalGeneration, processor: Qwen3VLProcessor, transformer: QwenImage21Transformer2DModel, sample_sigmas: list[float] | None = None)
```

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

**Parámetros:**

scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/es/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Programador utilizado para desruidar los latentes de la imagen codificada.

vae ([AutoencoderKLQwenImage21](/docs/diffusers/main/es/api/models/autoencoderkl_qwenimage21#diffusers.AutoencoderKLQwenImage21)) : Autoencoder variacional que mapea imágenes hacia y desde el espacio latente de 64 canales.

text_encoder (`Qwen3VLForConditionalGeneration`) : modelo Qwen3-VL que genera las incrustaciones conjuntas de texto e imagen.

processor (`Qwen3VLProcessor`) : Procesador que construye la plantilla de chat y tokeniza el prompt y las imágenes de condición.

transformer ([QwenImage21Transformer2DModel](/docs/diffusers/main/es/api/models/qwenimage21_transformer2d#diffusers.QwenImage21Transformer2DModel)) : El transformer de flujo único con causalidad por bloques que desruidiza los latentes.

sample_sigmas (`list[float]`, *opcional*) : Sigmas de muestreo predeterminados configurados por el autor del modelo, excluyendo la sigma terminal. Su longitud determina el número de pasos de desruido. Para experimentar con una cuadrícula diferente en tiempo de ejecución, pase `sigmas` a `__call__`.

Generación de texto a imagen y generación condicionada por imagen con Qwen-Image 2.1.

Las imágenes de prompt y de condición se codifican juntas mediante un modelo Qwen3-VL, por lo que una imagen de condición ocupa los espacios de visión que el codificador reservó para ella y el transformer ve una secuencia intercalada de texto e imágenes.

#### __call__[[diffusers.QwenImage21Pipeline.__call__]]

```python
__call__(prompt: str | list[str] = None, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, negative_prompt: str | list[str] = None, true_cfg_scale: float = 1.0, height: int | None = None, width: int | None = None, num_inference_steps: int = 40, sigmas: list[float] | None = None, num_images_per_prompt: int = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_embeds_mask: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds_mask: typing.Optional[torch.Tensor] = None, output_type: str | None = 'pil', return_dict: bool = True, attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Optional[typing.Callable[[int, int, dict], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], output_resolution: int = 1024, use_kv_cache: bool = True)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/qwenimage21/pipeline_qwenimage21.py#L509)

**Parámetros:**

prompt (`str` o `list[str]`, *opcional*) : El prompt para guiar la generación de imágenes. Pasa `prompt_embeds` en su lugar para proporcionar embeddings directamente.

image (`PipelineImageInput`, *opcional*) : Una o más imágenes de condición, como una imagen PIL o un array de numpy. Se codifican por el codificador de texto como contexto visual y por el VAE en tokens latentes que se antepone al ruido. Una lista es un conjunto de imágenes compartido por cada prompt del lote, no una entrada por prompt.

negative_prompt (`str` o `list[str]`, *opcional*) : El prompt para no guiar la generación de imágenes. Se ignora cuando `true_cfg_scale` no es mayor que 1.

true_cfg_scale (`float`, *opcional*, valor predeterminado 1.0) : Escala de guía libre de clasificador. Se habilita con `true_cfg_scale > 1` junto con un prompt negativo. Qwen-Image 2.1 está diseñado para muestrear sin guía, por lo que el valor predeterminado es 1.0.

height (`int`, *opcional*) : Altura en píxeles de la imagen generada. Se deriva de la relación de aspecto de la imagen de condición si se omite.

width (`int`, *opcional*) : Ancho en píxeles de la imagen generada. Si se omite, se deriva de la relación de aspecto de la imagen de condición.

num_inference_steps (`int`, *opcional*, valor predeterminado 40) : Número de pasos de desruido. Se ignora cuando se usa `sigmas` o el `sample_sigmas` configurado en el pipeline; la longitud de esa programación determina el número de pasos.

sigmas (`list[float]`, *opcional*) : Sigmas de muestreo a probar en esta llamada, excluyendo la sigma terminal. Anula el `sample_sigmas` configurado en el pipeline y determina el número de pasos de desruido. El programador aplica su procesamiento configurado a estos valores.

num_images_per_prompt (`int`, *opcional*, valor predeterminado 1) : Número de imágenes generadas por indicación.

generator (`torch.Generator` o `list[torch.Generator]`, *opcional*) : Generador(es) para hacer la generación determinista.

latents (`torch.Tensor`, *opcional*) : Latentes ruidosos pregenerados.

prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pregenerados, que omiten la codificación del prompt. Pásalos junto con `prompt_embeds_mask`.

prompt_embeds_mask (`torch.Tensor`, *opcional*) : Máscara booleana que marca las posiciones válidas de `prompt_embeds`.

negative_prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto negativo pregenerados, utilizados en lugar de `negative_prompt`. Pasa `negative_prompt_embeds_mask` junto con ellos.

negative_prompt_embeds_mask (`torch.Tensor`, *opcional*) : Máscara de Bool que marca las posiciones válidas de `negative_prompt_embeds`.

output_type (`str`, *opcional*, por defecto `"pil"`) : Formato de salida, `"pil"`, `"np"`, `"pt"` o `"latent"`.

return_dict (`bool`, *opcional*, valor predeterminado `True`) : Si se debe devolver un `~pipelines.qwenimage.QwenImagePipelineOutput` en lugar de una tupla simple.

attention_kwargs (`dict`, *opcional*) : Se transmite al procesador de atención.

callback_on_step_end (`Callable`, *opcional*) : Se llama al final de cada paso de desruido.

callback_on_step_end_tensor_inputs (`list[str]`, *opcional*, valor predeterminado `["latents"]`) : Tensors del bucle de desruido para pasar a `callback_on_step_end`. Deben estar listados en `_callback_tensor_inputs` del pipeline.

output_resolution (`int`, *opcional*, valor predeterminado 1024) : Longitud del lado objetivo utilizada para derivar `height`/`width` y para redimensionar las imágenes de condición.

use_kv_cache (`bool`, *opcional*, valor predeterminado `True`) : Almacena en caché las claves y valores de texto e imagen de condición después del primer paso. Es válido porque `causal_condition` modula esos tokens desde `t = 0`, lo que hace que sus activaciones sean independientes del paso. Alternar esta opción no reproduce la misma imagen bit a bit en precisión reducida. La caché hace que el paso de decodificación atienda con un diseño de secuencia diferente al del paso de prellenado, por lo que ambos se dividen en baldosas de manera diferente y caen en redondeos distintos; ambos coinciden con una referencia en fp32 dentro de la misma tolerancia. Una diferencia de un ULP en el primer bloque se amplifica entonces por 32 bloques y cada paso del muestreador, por lo que ambas configuraciones producen muestras igualmente válidas pero visualmente distintas. Para fijar una muestra, fije esta bandera.

**Devuelve:** `~pipelines.qwenimage.QwenImagePipelineOutput` o `tuple`

`~pipelines.qwenimage.QwenImagePipelineOutput` si `return_dict` es True, de lo contrario una `tuple` cuyo 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 QwenImage21Pipeline

>>> pipe = QwenImage21Pipeline.from_pretrained("Qwen/Qwen-Image-2.1", dtype=torch.bfloat16)
>>> pipe.to("cuda")
>>> prompt = "A capybara wearing a wizard hat, reading a book by candlelight, oil painting"
>>> image = pipe(prompt).images[0]
>>> image.save("qwenimage21.png")
```

#### encode_prompt[[diffusers.QwenImage21Pipeline.encode_prompt]]

```python
encode_prompt(prompt: str | list[str], image: list[typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]] | None = None, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_embeds_mask: typing.Optional[torch.Tensor] = None, image_pad_mask: typing.Optional[torch.Tensor] = None)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/qwenimage21/pipeline_qwenimage21.py#L339)

**Parámetros:**

prompt (`str` o `list[str]`, *opcional*) : Prompt que se codificará.

image (`list[PipelineImageInput]`, *opcional*) : Imágenes de condición para codificar junto con el prompt.

device (`torch.device`) : Dispositivo de Torch.

num_images_per_prompt (`int`) : Número de imágenes generadas por indicación.

prompt_embeds (`torch.Tensor`, *opcional*) : Embeddings de texto pregenerados. Omite la codificación si se proporcionan.

## QwenImagePipelineOutput[[diffusers.pipelines.qwenimage.pipeline_output.QwenImagePipelineOutput]]

#### diffusers.pipelines.qwenimage.pipeline_output.QwenImagePipelineOutput[[diffusers.pipelines.qwenimage.pipeline_output.QwenImagePipelineOutput]]

```python
diffusers.pipelines.qwenimage.pipeline_output.QwenImagePipelineOutput(images: list[PIL.Image.Image] | numpy.ndarray)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/qwenimage/pipeline_output.py#L10)

**Parámetros:**

images (`list[PIL.Image.Image]` o `np.ndarray`) : lista de imágenes PIL desruidas de longitud `batch_size` o matriz numpy de forma `(batch_size, height, width, num_channels)`. Las imágenes PIL o la matriz numpy presentan las imágenes desruidas del pipeline de difusión.

Clase de salida para las tuberías de Stable Diffusion.

## QwenImage21ModularPipeline[[diffusers.QwenImage21ModularPipeline]]

#### diffusers.QwenImage21ModularPipeline[[diffusers.QwenImage21ModularPipeline]]

```python
diffusers.QwenImage21ModularPipeline(blocks: diffusers.modular_pipelines.modular_pipeline.ModularPipelineBlocks | None = None, pretrained_model_name_or_path: str | os.PathLike | None = None, components_manager: diffusers.modular_pipelines.components_manager.ComponentsManager | None = None, collection: str | None = None, workflow: str | None = None, modular_config_dict: dict[str, typing.Any] | None = None, config_dict: dict[str, typing.Any] | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/qwenimage21/modular_pipeline.py#L23)

Un ModularPipeline para Qwen-Image 2.1.

## QwenImage21AutoBlocks[[diffusers.QwenImage21AutoBlocks]]

#### diffusers.QwenImage21AutoBlocks[[diffusers.QwenImage21AutoBlocks]]

```python
diffusers.QwenImage21AutoBlocks()
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/qwenimage21/modular_blocks_qwenimage21.py#L497)

Pipeline modular automático para la generación de texto a imagen y generación condicionada por imagen usando Qwen-Image 2.1.
- para la generación de texto a imagen, solo necesitas proporcionar `prompt`
- para la generación condicionada por imagen, debes proporcionar `prompt` e `image` (una imagen o una lista)

Flujos de trabajo admitidos:
- `text2image`: requiere `prompt`
- `image_conditioned`: requiere `prompt`, `image`

Componentes: image_processor (`VaeImageProcessor`) text_encoder (`Qwen3VLForConditionalGeneration`) processor (`Qwen3VLProcessor`) vae (`AutoencoderKLQwenImage21`) scheduler (`FlowMatchEulerDiscreteScheduler`) guider (`ClassifierFreeGuidance`) transformer (`QwenImage21Transformer2DModel`)

Entradas: image (`Image | list`, *opcional*): Imagen(es) de referencia para el desruido. Puede ser una sola imagen o una lista de imágenes. output_resolution (`int`, *opcional*, valor predeterminado 1024): Longitud del lado objetivo utilizada para derivar el tamaño de salida y para redimensionar las imágenes de condición. prompt (`str`): El prompt o prompts para guiar la generación de imágenes. negative_prompt (`str`, *opcional*): El prompt o prompts que no deben guiar la generación de imágenes. generator (`Generator`, *opcional*): Generador de Torch para una generación determinista. num_images_per_prompt (`int`, *opcional*, valor predeterminado 1): El número de imágenes a generar por prompt. height (`int`, *opcional*): La altura en píxeles de la imagen generada. width (`int`, *opcional*): El ancho en píxeles de la imagen generada. image_latents (`list`, *opcional*): Latentes normalizados de cada imagen de condición. Pueden generarse desde el paso vae_encoder. latents (`Tensor`): Latentes ruidosos pregenerados para la generación de imágenes. num_inference_steps (`int`): El número de pasos de desruido. sigmas (`list`, *opcional*): Sigmas personalizados para el proceso de desruido. use_kv_cache (`bool`, *opcional*, valor predeterminado True): Almacena en caché las claves y valores del texto y de la imagen de condición después del primer paso. Es válido porque `causal_condition` modula esos tokens desde `t = 0`, lo que hace que sus activaciones sean independientes del paso. Alternar esta opción no reproduce la misma imagen bit a bit en precisión reducida. attention_kwargs (`dict`, *opcional*): Kwargs adicionales para los procesadores de atención. **denoiser_input_fields (`None`, *opcional*): Entradas del modelo condicional para el desruidador: por ejemplo, prompt_embeds, negative_prompt_embeds, etc. output_type (`str`, *opcional*, valor predeterminado pil): Formato de salida: 'pil', 'np', 'pt'.

Salidas: imágenes (`list`): Imágenes generadas.

## QwenImage21TurboModularPipeline[[diffusers.QwenImage21TurboModularPipeline]]

#### diffusers.QwenImage21TurboModularPipeline[[diffusers.QwenImage21TurboModularPipeline]]

```python
diffusers.QwenImage21TurboModularPipeline(blocks: diffusers.modular_pipelines.modular_pipeline.ModularPipelineBlocks | None = None, pretrained_model_name_or_path: str | os.PathLike | None = None, components_manager: diffusers.modular_pipelines.components_manager.ComponentsManager | None = None, collection: str | None = None, workflow: str | None = None, modular_config_dict: dict[str, typing.Any] | None = None, config_dict: dict[str, typing.Any] | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/qwenimage21/modular_pipeline.py#L54)

Un ModularPipeline para Qwen-Image 2.1 Turbo, el punto de control acelerado que muestrea en pocos pasos sin guía.

## QwenImage21TurboAutoBlocks[[diffusers.QwenImage21TurboAutoBlocks]]

#### diffusers.QwenImage21TurboAutoBlocks[[diffusers.QwenImage21TurboAutoBlocks]]

```python
diffusers.QwenImage21TurboAutoBlocks()
```

[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/modular_pipelines/qwenimage21/modular_blocks_qwenimage21_turbo.py#L466)

Auto Modular pipeline para la generación de texto a imagen y la generación condicionada por imagen, utilizando Qwen-Image 2.1 Turbo, el checkpoint acelerado que muestrea su cuadrícula de sigma incluida en pocos pasos sin guía.
- para la generación de texto a imagen, solo necesitas proporcionar `prompt`
- para la generación condicionada por imagen, debes proporcionar `prompt` e `image` (una imagen o una lista)

Flujos de trabajo admitidos:
- `text2image`: requiere `prompt`
- `image_conditioned`: requiere `prompt`, `image`

Componentes: image_processor (`VaeImageProcessor`) text_encoder (`Qwen3VLForConditionalGeneration`) processor (`Qwen3VLProcessor`) vae (`AutoencoderKLQwenImage21`) scheduler (`FlowMatchEulerDiscreteScheduler`) transformer (`QwenImage21Transformer2DModel`)

Configs: sample_sigmas (predeterminado: None): Cuadrícula de muestreo que se incluye con el punto de control, utilizada cuando no se pasa `sigmas`.

Entradas: image (`Image | list`, *opcional*): Imagen(es) de referencia para el desruido. Puede ser una sola imagen o una lista de imágenes. output_resolution (`int`, *opcional*, valor predeterminado 1024): Longitud del lado objetivo utilizada para derivar el tamaño de salida y para redimensionar las imágenes de condición. prompt (`str`): El prompt o prompts para guiar la generación de imágenes. generator (`Generator`, *opcional*): Generador de Torch para una generación determinista. num_images_per_prompt (`int`, *opcional*, valor predeterminado 1): El número de imágenes a generar por prompt. height (`int`, *opcional*): La altura en píxeles de la imagen generada. width (`int`, *opcional*): El ancho en píxeles de la imagen generada. image_latents (`list`, *opcional*): Latentes normalizados de cada imagen de condición. Pueden generarse desde el paso vae_encoder. latents (`Tensor`): Latentes ruidosos pregenerados para la generación de imágenes. num_inference_steps (`int`): El número de pasos de desruido. sigmas (`list`, *opcional*): Sigmas personalizados para el proceso de desruido. use_kv_cache (`bool`, *opcional*, valor predeterminado True): Almacena en caché las claves y valores del texto y de la imagen de condición después del primer paso. Es válido porque `causal_condition` modula esos tokens desde `t = 0`, lo que hace que sus activaciones sean independientes del paso. Alternar esta opción no reproduce la misma imagen bit a bit en precisión reducida. attention_kwargs (`dict`, *opcional*): Kwargs adicionales para los procesadores de atención. **denoiser_input_fields (`None`, *opcional*): Entradas del modelo condicional para el desruidador: p. ej. prompt_embeds, negative_prompt_embeds, etc. output_type (`str`, *opcional*, valor predeterminado pil): Formato de salida: 'pil', 'np', 'pt'.

Salidas: imágenes (`list`): Imágenes generadas.