Buckets:
#
# Bajo licencia Apache License, versión 2.0 (la "Licencia");
# no puede usar este archivo excepto en cumplimiento de la Licencia.
# Puede obtener una copia de la Licencia en
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# A menos que la ley aplicable lo exija o se haya acordado por escrito, el software
# distribuido bajo la Licencia se distribuye en una base "TAL CUAL",
# SIN GARANTÍAS NI CONDICIONES DE NINGÚN TIPO, ya sea expresa o implícita.
# Consulte la Licencia para el lenguaje específico que rige los permisos y
# limitaciones de la Licencia. -->
# QwenImage
Qwen-Image, del equipo Qwen, es un modelo base de generación de imágenes de la serie Qwen que logra avances significativos en el renderizado de texto complejo y la edición precisa de imágenes. Los experimentos muestran capacidades generales sólidas tanto en la generación como en la edición de imágenes, con un rendimiento excepcional en el renderizado de texto, especialmente para el chino.
Qwen-Image está disponible en las siguientes variantes:
| tipo de modelo | id del modelo |
|:----------:|:--------:|
| Qwen-Image | [`Qwen/Qwen-Image`](https://huggingface.co/Qwen/Qwen-Image) |
| Qwen-Image-Edit | [`Qwen/Qwen-Image-Edit`](https://huggingface.co/Qwen/Qwen-Image-Edit) |
| Qwen-Image-Edit Plus | [Qwen/Qwen-Image-Edit-2509](https://huggingface.co/Qwen/Qwen-Image-Edit-2509) |
> [!TIP]
> Consulte la guía de [Caching](../../optimization/cache) para acelerar la inferencia almacenando y reutilizando salidas intermedias.
## LoRA para una inferencia más rápida
Usa un LoRA de `lightx2v/Qwen-Image-Lightning` para acelerar la inferencia reduciendo el número de pasos. Consulta el fragmento de código a continuación:
Código
```py
from diffusers import DiffusionPipeline, FlowMatchEulerDiscreteScheduler
import torch
import math
ckpt_id = "Qwen/Qwen-Image"
# From
# https://github.com/ModelTC/Qwen-Image-Lightning/blob/342260e8f5468d2f24d084ce04f55e101007118b/generate_with_diffusers.py#L82C9-L97C10
scheduler_config = {
"base_image_seq_len": 256,
"base_shift": math.log(3), # We use shift=3 in distillation
"invert_sigmas": False,
"max_image_seq_len": 8192,
"max_shift": math.log(3), # We use shift=3 in distillation
"num_train_timesteps": 1000,
"shift": 1.0,
"shift_terminal": None, # set shift_terminal to None
"stochastic_sampling": False,
"time_shift_type": "exponential",
"use_beta_sigmas": False,
"use_dynamic_shifting": True,
"use_exponential_sigmas": False,
"use_karras_sigmas": False,
}
scheduler = FlowMatchEulerDiscreteScheduler.from_config(scheduler_config)
pipe = DiffusionPipeline.from_pretrained(
ckpt_id, scheduler=scheduler, dtype=torch.bfloat16
).to("cuda") # or "mps", "xpu", "cpu"
pipe.load_lora_weights(
"lightx2v/Qwen-Image-Lightning", weight_name="Qwen-Image-Lightning-8steps-V1.0.safetensors"
)
prompt = "a tiny astronaut hatching from an egg on the moon, Ultra HD, 4K, cinematic composition."
negative_prompt = " "
image = pipe(
prompt=prompt,
negative_prompt=negative_prompt,
width=1024,
height=1024,
num_inference_steps=8,
true_cfg_scale=1.0,
generator=torch.manual_seed(0),
).images[0]
image.save("qwen_fewsteps.png")
```
> [!TIP]
> El parámetro `guidance_scale` en el pipeline está ahí para soportar futuros modelos destilados con guía cuando aparezcan. Tenga en cuenta que pasar `guidance_scale` al pipeline no tiene efecto. Para habilitar la guía sin clasificador, pase `true_cfg_scale` y `negative_prompt` (incluso un prompt negativo vacío como " ") debería habilitar los cálculos de guía sin clasificador.
## Referencia de múltiples imágenes con QwenImageEditPlusPipeline
Con [QwenImageEditPlusPipeline](/docs/diffusers/main/es/api/pipelines/qwenimage#diffusers.QwenImageEditPlusPipeline), se pueden proporcionar varias imágenes como referencia de entrada.
```py
import torch
from PIL import Image
from diffusers import QwenImageEditPlusPipeline
from diffusers.utils import load_image
pipe = QwenImageEditPlusPipeline.from_pretrained(
"Qwen/Qwen-Image-Edit-2509", dtype=torch.bfloat16
).to("cuda") # or "mps", "xpu", "cpu"
image_1 = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/grumpy.jpg")
image_2 = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/peng.png")
image = pipe(
image=[image_1, image_2],
prompt='''put the penguin and the cat at a game show called "Qwen Edit Plus Games"''',
num_inference_steps=50
).images[0]
```
## Rendimiento
### torch.compile
El uso de `torch.compile` en el transformer proporciona una aceleración de ~2.4x (A100 80GB: 4.70s → 1.93s):
```python
import torch
from diffusers import QwenImagePipeline
pipe = QwenImagePipeline.from_pretrained("Qwen/Qwen-Image", dtype=torch.bfloat16).to("cuda") # or "mps", "xpu", "cpu"
pipe.transformer = torch.compile(pipe.transformer)
# First call triggers compilation (~7s overhead)
# Subsequent calls run at ~2.4x faster
image = pipe("a cat", num_inference_steps=50).images[0]
```
### Inferencia por lotes con prompts de longitud variable
Al usar la guía sin clasificador (CFG) con prompts de diferentes longitudes, el pipeline maneja correctamente el relleno mediante la enmascaración de atención. Esto garantiza que los tokens de relleno no influyan en la salida generada.
```python
# CFG with different prompt lengths works correctly
image = pipe(
prompt="A cat",
negative_prompt="blurry, low quality, distorted",
true_cfg_scale=3.5,
num_inference_steps=50,
).images[0]
```
Para obtener los scripts y resultados de las pruebas de rendimiento detalladas, consulte [este gist](https://gist.github.com/cdutr/bea337e4680268168550292d7819dc2f).
## QwenImagePipeline[[diffusers.QwenImagePipeline]]
#### diffusers.QwenImagePipeline[[diffusers.QwenImagePipeline]]
```python
diffusers.QwenImagePipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKLQwenImage, text_encoder: Qwen2_5_VLForConditionalGeneration, tokenizer: Qwen2Tokenizer, transformer: QwenImageTransformer2DModel)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/qwenimage/pipeline_qwenimage.py#L132)
**Parámetros:**
transformer ([QwenImageTransformer2DModel](/docs/diffusers/main/es/api/models/qwenimage_transformer2d#diffusers.QwenImageTransformer2DModel)) : Arquitectura de Transformer condicional (MMDiT) para desruidar los latentes de imagen codificados.
scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/es/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Un programador para usar en combinación con `transformer` para desruidar los latentes de imagen codificados.
vae ([AutoencoderKL](/docs/diffusers/main/es/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modelo de Variational Auto-Encoder (VAE) para codificar y decodificar imágenes hacia y desde representaciones latentes.
text_encoder (`Qwen2.5-VL-7B-Instruct`) : [Qwen2.5-VL-7B-Instruct](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct), específicamente la variante [Qwen2.5-VL-7B-Instruct](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct).
tokenizer (`Qwen2Tokenizer`) : Tokenizador de la clase https://huggingface.co/docs/transformers/en/model_doc/qwen2#transformers.Qwen2Tokenizer
El pipeline QwenImage para la generación de imágenes a partir de texto.
#### __call__[[diffusers.QwenImagePipeline.__call__]]
```python
__call__(prompt: str | list[str] = None, negative_prompt: str | list[str] = None, true_cfg_scale: float = 4.0, height: int | None = None, width: int | None = None, num_inference_steps: int = 50, sigmas: list[float] | None = None, guidance_scale: 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], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/qwenimage/pipeline_qwenimage.py#L408)
**Parámetros:**
prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar la generación de la imagen. Si no se define, se debe pasar `prompt_embeds` en su lugar.
negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (es decir, se ignora si `true_cfg_scale` no es mayor que `1`).
true_cfg_scale (`float`, *opcional*, valor predeterminado 1.0) : Escala de orientación definida en [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `true_cfg_scale` se define como `w` de la ecuación 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). La orientación libre de clasificador se habilita estableciendo `true_cfg_scale > 1` y proporcionando un `negative_prompt`. 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.
height (`int`, *opcional*, por defecto self.unet.config.sample_size * self.vae_scale_factor) : La altura en píxeles de la imagen generada. Por defecto, se establece en 1024 para obtener los mejores resultados.
width (`int`, *opcional*, por defecto self.unet.config.sample_size * self.vae_scale_factor) : El ancho en píxeles de la imagen generada. Por defecto, se establece en 1024 para obtener los mejores resultados.
num_inference_steps (`int`, *opcional*, valor predeterminado 50) : 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.
sigmas (`list[float]`, *opcional*) : Sigmas personalizados para usar en el proceso de desruido con programadores que admiten un argumento `sigmas` en su método `set_timesteps`. Si no se define, se usará el comportamiento predeterminado cuando se pase `num_inference_steps`.
guidance_scale (`float`, *opcional*, valor predeterminado None) : Un valor de escala de guía para modelos destilados de guía. A diferencia de la guía libre de clasificador tradicional, donde la escala de guía se aplica durante la inferencia mediante el reescalado de la predicción de ruido, los modelos destilados de guía toman la escala de guía directamente como un parámetro de entrada durante la pasada hacia adelante. La escala de guía se habilita estableciendo `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. Este parámetro en el pipeline está presente para soportar futuros modelos destilados de guía cuando aparezcan. Se ignora cuando no se utilizan modelos destilados de guía. Para habilitar la guía libre de clasificador tradicional, pase `true_cfg_scale > 1.0` y `negative_prompt` (incluso un prompt negativo vacío como " " debería habilitar los cálculos de guía libre de clasificador).
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.
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_mask (`torch.Tensor`, *opcional*) : Máscara de atención para `prompt_embeds`.
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_mask (`torch.Tensor`, *opcional*) : Máscara de atención para `negative_prompt_embeds`.
output_type (`str`, *opcional*, por defecto `"pil"`) : El formato de salida de la imagen generada. Elija entre [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` o `np.array`.
return_dict (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe devolver un `~pipelines.qwenimage.QwenImagePipelineOutput` en lugar de una tupla simple.
attention_kwargs (`dict`, *opcional*) : Un diccionario de kwargs que, si se especifica, se pasa al `AttentionProcessor` tal como se define bajo `self.processor` en [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).
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.
max_sequence_length (`int` por defecto 512) : Longitud máxima de secuencia para usar con el `prompt`.
**Devuelve:** `~pipelines.qwenimage.QwenImagePipelineOutput` o `tuple`
`~pipelines.qwenimage.QwenImagePipelineOutput` 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 QwenImagePipeline
>>> pipe = QwenImagePipeline.from_pretrained("Qwen/Qwen-Image", torch_dtype=torch.bfloat16)
>>> pipe.to("cuda")
>>> prompt = "A cat holding a sign that says hello world"
>>> # Depending on the variant being used, the pipeline call will slightly vary.
>>> # Refer to the pipeline documentation for more details.
>>> image = pipe(prompt, num_inference_steps=50).images[0]
>>> image.save("qwenimage.png")
```
#### encode_prompt[[diffusers.QwenImagePipeline.encode_prompt]]
```python
encode_prompt(prompt: str | list[str], 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, max_sequence_length: int = 1024)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/qwenimage/pipeline_qwenimage.py#L225)
**Parámetros:**
prompt (`str` o `list[str]`, *opcional*) : prompt a codificar
device : (`torch.device`): dispositivo de torch
num_images_per_prompt (`int`) : número de imágenes que deben generarse por prompt
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`.
## QwenImageImg2ImgPipeline[[diffusers.QwenImageImg2ImgPipeline]]
#### diffusers.QwenImageImg2ImgPipeline[[diffusers.QwenImageImg2ImgPipeline]]
```python
diffusers.QwenImageImg2ImgPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKLQwenImage, text_encoder: Qwen2_5_VLForConditionalGeneration, tokenizer: Qwen2Tokenizer, transformer: QwenImageTransformer2DModel)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/qwenimage/pipeline_qwenimage_img2img.py#L134)
**Parámetros:**
transformer ([QwenImageTransformer2DModel](/docs/diffusers/main/es/api/models/qwenimage_transformer2d#diffusers.QwenImageTransformer2DModel)) : Arquitectura de Transformer condicional (MMDiT) para desruidar los latentes de imagen codificados.
scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/es/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Un programador para usar en combinación con `transformer` para desruidar los latentes de imagen codificados.
vae ([AutoencoderKL](/docs/diffusers/main/es/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modelo de Variational Auto-Encoder (VAE) para codificar y decodificar imágenes hacia y desde representaciones latentes.
text_encoder (`Qwen2.5-VL-7B-Instruct`) : [Qwen2.5-VL-7B-Instruct](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct), específicamente la variante [Qwen2.5-VL-7B-Instruct](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct).
tokenizer (`Qwen2Tokenizer`) : Tokenizador de la clase https://huggingface.co/docs/transformers/en/model_doc/qwen2#transformers.Qwen2Tokenizer
El pipeline QwenImage para la generación de imágenes a partir de texto.
#### __call__[[diffusers.QwenImageImg2ImgPipeline.__call__]]
```python
__call__(prompt: str | list[str] = None, negative_prompt: str | list[str] = None, true_cfg_scale: float = 4.0, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, height: int | None = None, width: int | None = None, strength: float = 0.6, num_inference_steps: int = 50, sigmas: list[float] | None = None, guidance_scale: 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], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/qwenimage/pipeline_qwenimage_img2img.py#L482)
**Parámetros:**
prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar la generación de la imagen. Si no se define, se debe pasar `prompt_embeds` en su lugar.
negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (es decir, se ignora si `true_cfg_scale` no es mayor que `1`).
image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]` o `list[np.ndarray]`) : `Image`, array de numpy o tensor que representa un lote de imágenes para usarse como punto de partida. Tanto para arrays de numpy como para tensors de PyTorch, el rango de valores esperado está entre `[0, 1]`. Si es un tensor o una lista de tensors, la forma esperada debe ser `(B, C, H, W)` o `(C, H, W)`. Si es un array de numpy o una lista de arrays, la forma esperada debe ser `(B, H, W, C)` o `(H, W, C)`. También puede aceptar latentes de imagen como `image`, pero si se pasan latentes directamente, no se vuelven a codificar.
true_cfg_scale (`float`, *opcional*, valor predeterminado 1.0) : Escala de orientación definida en [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `true_cfg_scale` se define como `w` de la ecuación 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). La orientación libre de clasificador se habilita estableciendo `true_cfg_scale > 1` y proporcionando un `negative_prompt`. 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.
height (`int`, *opcional*, por defecto self.unet.config.sample_size * self.vae_scale_factor) : La altura en píxeles de la imagen generada. Por defecto, se establece en 1024 para obtener los mejores resultados.
width (`int`, *opcional*, por defecto self.unet.config.sample_size * self.vae_scale_factor) : El ancho en píxeles de la imagen generada. Por defecto, se establece en 1024 para obtener los mejores resultados.
strength (`float`, *opcional*, valor predeterminado 1.0) : Indica el grado en que se transforma la `image` de referencia. Debe estar entre 0 y 1. `image` se utiliza como punto de partida y se añade más ruido a medida que aumenta el `strength`. El número de pasos de desruido depende de la cantidad de ruido añadido inicialmente. Cuando `strength` es 1, el ruido añadido es máximo y el proceso de desruido se ejecuta durante el número completo de iteraciones especificado en `num_inference_steps`. Un valor de 1 ignora esencialmente `image`.
num_inference_steps (`int`, *opcional*, valor predeterminado 50) : 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.
sigmas (`list[float]`, *opcional*) : Sigmas personalizados para usar en el proceso de desruido con programadores que admiten un argumento `sigmas` en su método `set_timesteps`. Si no se define, se usará el comportamiento predeterminado cuando se pase `num_inference_steps`.
guidance_scale (`float`, *opcional*, valor predeterminado None) : Un valor de escala de guía para modelos destilados de guía. A diferencia de la guía libre de clasificador tradicional, donde la escala de guía se aplica durante la inferencia mediante el reescalado de la predicción de ruido, los modelos destilados de guía toman la escala de guía directamente como un parámetro de entrada durante la pasada hacia adelante. La escala de guía se habilita estableciendo `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. Este parámetro en el pipeline está presente para soportar futuros modelos destilados de guía cuando aparezcan. Se ignora cuando no se utilizan modelos destilados de guía. Para habilitar la guía libre de clasificador tradicional, pase `true_cfg_scale > 1.0` y `negative_prompt` (incluso un prompt negativo vacío como " " debería habilitar los cálculos de guía libre de clasificador).
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.
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_mask (`torch.Tensor`, *opcional*) : Máscara de atención para `prompt_embeds`.
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_mask (`torch.Tensor`, *opcional*) : Máscara de atención para `negative_prompt_embeds`.
output_type (`str`, *opcional*, por defecto `"pil"`) : El formato de salida de la imagen generada. Elija entre [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` o `np.array`.
return_dict (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe devolver un `~pipelines.qwenimage.QwenImagePipelineOutput` en lugar de una tupla simple.
attention_kwargs (`dict`, *opcional*) : Un diccionario de kwargs que, si se especifica, se pasa al `AttentionProcessor` tal como se define bajo `self.processor` en [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).
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.
max_sequence_length (`int` por defecto 512) : Longitud máxima de secuencia para usar con el `prompt`.
**Devuelve:** `~pipelines.qwenimage.QwenImagePipelineOutput` o `tuple`
`~pipelines.qwenimage.QwenImagePipelineOutput` 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 QwenImageImg2ImgPipeline
>>> from diffusers.utils import load_image
>>> pipe = QwenImageImg2ImgPipeline.from_pretrained("Qwen/Qwen-Image", torch_dtype=torch.bfloat16)
>>> pipe = pipe.to("cuda")
>>> url = "https://raw.githubusercontent.com/CompVis/stable-diffusion/main/assets/stable-samples/img2img/sketch-mountains-input.jpg"
>>> init_image = load_image(url).resize((1024, 1024))
>>> prompt = "cat wizard, gandalf, lord of the rings, detailed, fantasy, cute, adorable, Pixar, Disney"
>>> images = pipe(prompt=prompt, negative_prompt=" ", image=init_image, strength=0.95).images[0]
>>> images.save("qwenimage_img2img.png")
```
#### encode_prompt[[diffusers.QwenImageImg2ImgPipeline.encode_prompt]]
```python
encode_prompt(prompt: str | list[str], 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, max_sequence_length: int = 1024)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/qwenimage/pipeline_qwenimage_img2img.py#L268)
**Parámetros:**
prompt (`str` o `list[str]`, *opcional*) : prompt a codificar
device : (`torch.device`): dispositivo de torch
num_images_per_prompt (`int`) : número de imágenes que deben generarse por prompt
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`.
## QwenImageInpaintPipeline[[diffusers.QwenImageInpaintPipeline]]
#### diffusers.QwenImageInpaintPipeline[[diffusers.QwenImageInpaintPipeline]]
```python
diffusers.QwenImageInpaintPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKLQwenImage, text_encoder: Qwen2_5_VLForConditionalGeneration, tokenizer: Qwen2Tokenizer, transformer: QwenImageTransformer2DModel)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/qwenimage/pipeline_qwenimage_inpaint.py#L137)
**Parámetros:**
transformer ([QwenImageTransformer2DModel](/docs/diffusers/main/es/api/models/qwenimage_transformer2d#diffusers.QwenImageTransformer2DModel)) : Arquitectura de Transformer condicional (MMDiT) para desruidar los latentes de imagen codificados.
scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/es/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Un programador para usar en combinación con `transformer` para desruidar los latentes de imagen codificados.
vae ([AutoencoderKL](/docs/diffusers/main/es/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modelo de Variational Auto-Encoder (VAE) para codificar y decodificar imágenes hacia y desde representaciones latentes.
text_encoder (`Qwen2.5-VL-7B-Instruct`) : [Qwen2.5-VL-7B-Instruct](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct), específicamente la variante [Qwen2.5-VL-7B-Instruct](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct).
tokenizer (`Qwen2Tokenizer`) : Tokenizador de la clase https://huggingface.co/docs/transformers/en/model_doc/qwen2#transformers.Qwen2Tokenizer
El pipeline QwenImage para la generación de imágenes a partir de texto.
#### __call__[[diffusers.QwenImageInpaintPipeline.__call__]]
```python
__call__(prompt: str | list[str] = None, negative_prompt: str | list[str] = None, true_cfg_scale: float = 4.0, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, mask_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, masked_image_latents: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, height: int | None = None, width: int | None = None, padding_mask_crop: int | None = None, strength: float = 0.6, num_inference_steps: int = 50, sigmas: list[float] | None = None, guidance_scale: 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], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/qwenimage/pipeline_qwenimage_inpaint.py#L592)
**Parámetros:**
prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar la generación de la imagen. Si no se define, se debe pasar `prompt_embeds` en su lugar.
negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (es decir, se ignora si `true_cfg_scale` no es mayor que `1`).
image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]` o `list[np.ndarray]`) : `Image`, array de numpy o tensor que representa un lote de imágenes para usarse como punto de partida. Tanto para arrays de numpy como para tensors de PyTorch, el rango de valores esperado está entre `[0, 1]`. Si es un tensor o una lista de tensors, la forma esperada debe ser `(B, C, H, W)` o `(C, H, W)`. Si es un array de numpy o una lista de arrays, la forma esperada debe ser `(B, H, W, C)` o `(H, W, C)`. También puede aceptar latentes de imagen como `image`, pero si se pasan latentes directamente, no se vuelven a codificar.
true_cfg_scale (`float`, *opcional*, valor predeterminado 1.0) : Escala de orientación definida en [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `true_cfg_scale` se define como `w` de la ecuación 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). La orientación libre de clasificador se habilita estableciendo `true_cfg_scale > 1` y proporcionando un `negative_prompt`. 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.
mask_image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]` o `list[np.ndarray]`) : `Image`, array de numpy o tensor que representa un lote de imágenes para enmascarar `image`. Los píxeles blancos de la máscara se repintan, mientras que los píxeles negros se conservan. Si `mask_image` es una imagen PIL, se convierte a un solo canal (luminancia) antes de su uso. Si es un array de numpy o un tensor de pytorch, debe contener un solo canal de color (L) en lugar de 3, por lo que la forma esperada para un tensor de pytorch sería `(B, 1, H, W)`, `(B, H, W)`, `(1, H, W)` o `(H, W)`. Y para un array de numpy sería `(B, H, W, 1)`, `(B, H, W)`, `(H, W, 1)` o `(H, W)`.
masked_image_latents (`torch.Tensor`, `list[torch.Tensor]`) : `Tensor` que representa un lote de imágenes para enmascarar la `image` generada por el VAE. Si no se proporciona, el tensor de latentes de la máscara se generará mediante `mask_image`.
height (`int`, *opcional*, por defecto self.unet.config.sample_size * self.vae_scale_factor) : La altura en píxeles de la imagen generada. Por defecto, se establece en 1024 para obtener los mejores resultados.
width (`int`, *opcional*, por defecto self.unet.config.sample_size * self.vae_scale_factor) : El ancho en píxeles de la imagen generada. Por defecto, se establece en 1024 para obtener los mejores resultados.
padding_mask_crop (`int`, *opcional*, valor predeterminado `None`) : El tamaño del margen en el recorte que se aplicará a la imagen y la máscara. Si es `None`, no se aplica ningún recorte a la imagen y a mask_image. Si `padding_mask_crop` no es `None`, primero se buscará una región rectangular con la misma relación de aspecto que la imagen y que contenga toda el área enmascarada, y luego se expandirá esa área en función de `padding_mask_crop`. A continuación, la imagen y mask_image se recortarán según el área expandida antes de redimensionarlas al tamaño original de la imagen para el inpainting. Esto es útil cuando el área enmascarada es pequeña mientras que la imagen es grande y contiene información irrelevante para el inpainting, como el fondo.
strength (`float`, *opcional*, valor predeterminado 1.0) : Indica el grado en que se transforma la `image` de referencia. Debe estar entre 0 y 1. `image` se utiliza como punto de partida y se añade más ruido a medida que aumenta el `strength`. El número de pasos de desruido depende de la cantidad de ruido añadido inicialmente. Cuando `strength` es 1, el ruido añadido es máximo y el proceso de desruido se ejecuta durante el número completo de iteraciones especificado en `num_inference_steps`. Un valor de 1 ignora esencialmente `image`.
num_inference_steps (`int`, *opcional*, valor predeterminado 50) : 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.
sigmas (`list[float]`, *opcional*) : Sigmas personalizados para usar en el proceso de desruido con programadores que admiten un argumento `sigmas` en su método `set_timesteps`. Si no se define, se usará el comportamiento predeterminado cuando se pase `num_inference_steps`.
guidance_scale (`float`, *opcional*, valor predeterminado None) : Un valor de escala de guía para modelos destilados de guía. A diferencia de la guía libre de clasificador tradicional, donde la escala de guía se aplica durante la inferencia mediante el reescalado de la predicción de ruido, los modelos destilados de guía toman la escala de guía directamente como un parámetro de entrada durante la pasada hacia adelante. La escala de guía se habilita estableciendo `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. Este parámetro en el pipeline está presente para soportar futuros modelos destilados de guía cuando aparezcan. Se ignora cuando no se utilizan modelos destilados de guía. Para habilitar la guía libre de clasificador tradicional, pase `true_cfg_scale > 1.0` y `negative_prompt` (incluso un prompt negativo vacío como " " debería habilitar los cálculos de guía libre de clasificador).
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.
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_mask (`torch.Tensor`, *opcional*) : Máscara de atención para `prompt_embeds`.
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_mask (`torch.Tensor`, *opcional*) : Máscara de atención para `negative_prompt_embeds`.
output_type (`str`, *opcional*, por defecto `"pil"`) : El formato de salida de la imagen generada. Elija entre [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` o `np.array`.
return_dict (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe devolver un `~pipelines.qwenimage.QwenImagePipelineOutput` en lugar de una tupla simple.
attention_kwargs (`dict`, *opcional*) : Un diccionario de kwargs que, si se especifica, se pasa al `AttentionProcessor` tal como se define bajo `self.processor` en [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).
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.
max_sequence_length (`int` por defecto 512) : Longitud máxima de secuencia para usar con el `prompt`.
**Devuelve:** `~pipelines.qwenimage.QwenImagePipelineOutput` o `tuple`
`~pipelines.qwenimage.QwenImagePipelineOutput` 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 QwenImageInpaintPipeline
>>> from diffusers.utils import load_image
>>> pipe = QwenImageInpaintPipeline.from_pretrained("Qwen/Qwen-Image", torch_dtype=torch.bfloat16)
>>> pipe.to("cuda")
>>> prompt = "Face of a yellow cat, high resolution, sitting on a park bench"
>>> img_url = "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo.png"
>>> mask_url = "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo_mask.png"
>>> source = load_image(img_url)
>>> mask = load_image(mask_url)
>>> image = pipe(prompt=prompt, negative_prompt=" ", image=source, mask_image=mask, strength=0.85).images[0]
>>> image.save("qwenimage_inpainting.png")
```
#### encode_prompt[[diffusers.QwenImageInpaintPipeline.encode_prompt]]
```python
encode_prompt(prompt: str | list[str], 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, max_sequence_length: int = 1024)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/qwenimage/pipeline_qwenimage_inpaint.py#L279)
**Parámetros:**
prompt (`str` o `list[str]`, *opcional*) : prompt a codificar
device : (`torch.device`): dispositivo de torch
num_images_per_prompt (`int`) : número de imágenes que deben generarse por prompt
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`.
## QwenImageEditPipeline[[diffusers.QwenImageEditPipeline]]
#### diffusers.QwenImageEditPipeline[[diffusers.QwenImageEditPipeline]]
```python
diffusers.QwenImageEditPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKLQwenImage, text_encoder: Qwen2_5_VLForConditionalGeneration, tokenizer: Qwen2Tokenizer, processor: Qwen2VLProcessor, transformer: QwenImageTransformer2DModel)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/qwenimage/pipeline_qwenimage_edit.py#L165)
**Parámetros:**
transformer ([QwenImageTransformer2DModel](/docs/diffusers/main/es/api/models/qwenimage_transformer2d#diffusers.QwenImageTransformer2DModel)) : Arquitectura de Transformer condicional (MMDiT) para desruidar los latentes de imagen codificados.
scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/es/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Un programador para usar en combinación con `transformer` para desruidar los latentes de imagen codificados.
vae ([AutoencoderKL](/docs/diffusers/main/es/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modelo de Variational Auto-Encoder (VAE) para codificar y decodificar imágenes hacia y desde representaciones latentes.
text_encoder (`Qwen2.5-VL-7B-Instruct`) : [Qwen2.5-VL-7B-Instruct](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct), específicamente la variante [Qwen2.5-VL-7B-Instruct](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct).
tokenizer (`Qwen2Tokenizer`) : Tokenizador de la clase https://huggingface.co/docs/transformers/en/model_doc/qwen2#transformers.Qwen2Tokenizer
El pipeline Qwen-Image-Edit para la edición de imágenes.
#### __call__[[diffusers.QwenImageEditPipeline.__call__]]
```python
__call__(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, prompt: str | list[str] = None, negative_prompt: str | list[str] = None, true_cfg_scale: float = 4.0, height: int | None = None, width: int | None = None, num_inference_steps: int = 50, sigmas: list[float] | None = None, guidance_scale: 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], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/qwenimage/pipeline_qwenimage_edit.py#L504)
**Parámetros:**
image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]` o `list[np.ndarray]`) : `Image`, array de numpy o tensor que representa un lote de imágenes para usarse como punto de partida. Tanto para arrays de numpy como para tensors de PyTorch, el rango de valores esperado está entre `[0, 1]`. Si es un tensor o una lista de tensors, la forma esperada debe ser `(B, C, H, W)` o `(C, H, W)`. Si es un array de numpy o una lista de arrays, la forma esperada debe ser `(B, H, W, C)` o `(H, W, C)`. También puede aceptar latentes de imagen como `image`, pero si se pasan latentes directamente, no se vuelven a codificar.
prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar la generación de la imagen. Si no se define, se debe pasar `prompt_embeds` en su lugar.
negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (es decir, se ignora si `true_cfg_scale` no es mayor que `1`).
true_cfg_scale (`float`, *opcional*, valor predeterminado 1.0) : true_cfg_scale (`float`, *opcional*, valor predeterminado 1.0): Escala de guía definida en [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `true_cfg_scale` se define como `w` de la ecuación 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). La guía sin clasificador se habilita estableciendo `true_cfg_scale > 1` y proporcionando un `negative_prompt`. 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.
height (`int`, *opcional*, por defecto self.unet.config.sample_size * self.vae_scale_factor) : La altura en píxeles de la imagen generada. Por defecto, se establece en 1024 para obtener los mejores resultados.
width (`int`, *opcional*, por defecto self.unet.config.sample_size * self.vae_scale_factor) : El ancho en píxeles de la imagen generada. Por defecto, se establece en 1024 para obtener los mejores resultados.
num_inference_steps (`int`, *opcional*, valor predeterminado 50) : 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.
sigmas (`list[float]`, *opcional*) : Sigmas personalizados para usar en el proceso de desruido con programadores que admiten un argumento `sigmas` en su método `set_timesteps`. Si no se define, se usará el comportamiento predeterminado cuando se pase `num_inference_steps`.
guidance_scale (`float`, *opcional*, valor predeterminado None) : Un valor de escala de guía para modelos destilados de guía. A diferencia de la guía libre de clasificador tradicional, donde la escala de guía se aplica durante la inferencia mediante el reescalado de la predicción de ruido, los modelos destilados de guía toman la escala de guía directamente como un parámetro de entrada durante la pasada hacia adelante. La escala de guía se habilita estableciendo `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. Este parámetro en el pipeline está presente para soportar futuros modelos destilados de guía cuando aparezcan. Se ignora cuando no se utilizan modelos destilados de guía. Para habilitar la guía libre de clasificador tradicional, pase `true_cfg_scale > 1.0` y `negative_prompt` (incluso un prompt negativo vacío como " " debería habilitar los cálculos de guía libre de clasificador).
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.
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_mask (`torch.Tensor`, *opcional*) : Máscara de atención para `prompt_embeds`.
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_mask (`torch.Tensor`, *opcional*) : Máscara de atención para `negative_prompt_embeds`.
output_type (`str`, *opcional*, por defecto `"pil"`) : El formato de salida de la imagen generada. Elija entre [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` o `np.array`.
return_dict (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe devolver un `~pipelines.qwenimage.QwenImagePipelineOutput` en lugar de una tupla simple.
attention_kwargs (`dict`, *opcional*) : Un diccionario de kwargs que, si se especifica, se pasa al `AttentionProcessor` tal como se define bajo `self.processor` en [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).
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.
max_sequence_length (`int` por defecto 512) : Longitud máxima de secuencia para usar con el `prompt`.
**Devuelve:** `~pipelines.qwenimage.QwenImagePipelineOutput` o `tuple`
`~pipelines.qwenimage.QwenImagePipelineOutput` 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 PIL import Image
>>> from diffusers import QwenImageEditPipeline
>>> from diffusers.utils import load_image
>>> pipe = QwenImageEditPipeline.from_pretrained("Qwen/Qwen-Image-Edit", torch_dtype=torch.bfloat16)
>>> pipe.to("cuda")
>>> image = load_image(
... "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/yarn-art-pikachu.png"
... ).convert("RGB")
>>> prompt = (
... "Make Pikachu hold a sign that says 'Qwen Edit is awesome', yarn art style, detailed, vibrant colors"
... )
>>> # Depending on the variant being used, the pipeline call will slightly vary.
>>> # Refer to the pipeline documentation for more details.
>>> image = pipe(image, prompt, num_inference_steps=50).images[0]
>>> image.save("qwenimage_edit.png")
```
#### encode_prompt[[diffusers.QwenImageEditPipeline.encode_prompt]]
```python
encode_prompt(prompt: str | list[str], image: typing.Optional[torch.Tensor] = 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, max_sequence_length: int = 1024)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/qwenimage/pipeline_qwenimage_edit.py#L272)
**Parámetros:**
prompt (`str` o `list[str]`, *opcional*) : prompt a codificar
image (`torch.Tensor`, *opcional*) : imagen a codificar
device : (`torch.device`): dispositivo de torch
num_images_per_prompt (`int`) : número de imágenes que deben generarse por prompt
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`.
## QwenImageEditInpaintPipeline[[diffusers.QwenImageEditInpaintPipeline]]
#### diffusers.QwenImageEditInpaintPipeline[[diffusers.QwenImageEditInpaintPipeline]]
```python
diffusers.QwenImageEditInpaintPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKLQwenImage, text_encoder: Qwen2_5_VLForConditionalGeneration, tokenizer: Qwen2Tokenizer, processor: Qwen2VLProcessor, transformer: QwenImageTransformer2DModel)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/qwenimage/pipeline_qwenimage_edit_inpaint.py#L167)
**Parámetros:**
transformer ([QwenImageTransformer2DModel](/docs/diffusers/main/es/api/models/qwenimage_transformer2d#diffusers.QwenImageTransformer2DModel)) : Arquitectura de Transformer condicional (MMDiT) para desruidar los latentes de imagen codificados.
scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/es/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Un programador para usar en combinación con `transformer` para desruidar los latentes de imagen codificados.
vae ([AutoencoderKL](/docs/diffusers/main/es/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modelo de Variational Auto-Encoder (VAE) para codificar y decodificar imágenes hacia y desde representaciones latentes.
text_encoder (`Qwen2.5-VL-7B-Instruct`) : [Qwen2.5-VL-7B-Instruct](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct), específicamente la variante [Qwen2.5-VL-7B-Instruct](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct).
tokenizer (`Qwen2Tokenizer`) : Tokenizador de la clase https://huggingface.co/docs/transformers/en/model_doc/qwen2#transformers.Qwen2Tokenizer
El pipeline Qwen-Image-Edit para la edición de imágenes.
#### __call__[[diffusers.QwenImageEditInpaintPipeline.__call__]]
```python
__call__(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, prompt: str | list[str] = None, negative_prompt: str | list[str] = None, mask_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, masked_image_latents: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, true_cfg_scale: float = 4.0, height: int | None = None, width: int | None = None, padding_mask_crop: int | None = None, strength: float = 0.6, num_inference_steps: int = 50, sigmas: list[float] | None = None, guidance_scale: 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], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/qwenimage/pipeline_qwenimage_edit_inpaint.py#L637)
**Parámetros:**
image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]` o `list[np.ndarray]`) : `Image`, array de numpy o tensor que representa un lote de imágenes para usarse como punto de partida. Tanto para arrays de numpy como para tensors de PyTorch, el rango de valores esperado está entre `[0, 1]`. Si es un tensor o una lista de tensors, la forma esperada debe ser `(B, C, H, W)` o `(C, H, W)`. Si es un array de numpy o una lista de arrays, la forma esperada debe ser `(B, H, W, C)` o `(H, W, C)`. También puede aceptar latentes de imagen como `image`, pero si se pasan latentes directamente, no se vuelven a codificar.
prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar la generación de la imagen. Si no se define, se debe pasar `prompt_embeds` en su lugar.
negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (es decir, se ignora si `true_cfg_scale` no es mayor que `1`).
true_cfg_scale (`float`, *opcional*, valor predeterminado 1.0) : true_cfg_scale (`float`, *opcional*, valor predeterminado 1.0): Escala de guía definida en [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `true_cfg_scale` se define como `w` de la ecuación 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). La guía sin clasificador se habilita estableciendo `true_cfg_scale > 1` y proporcionando un `negative_prompt`. 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.
mask_image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]` o `list[np.ndarray]`) : `Image`, array de numpy o tensor que representa un lote de imágenes para enmascarar `image`. Los píxeles blancos de la máscara se repintan, mientras que los píxeles negros se conservan. Si `mask_image` es una imagen PIL, se convierte a un solo canal (luminancia) antes de su uso. Si es un array de numpy o un tensor de pytorch, debe contener un solo canal de color (L) en lugar de 3, por lo que la forma esperada para un tensor de pytorch sería `(B, 1, H, W)`, `(B, H, W)`, `(1, H, W)` o `(H, W)`. Y para un array de numpy sería `(B, H, W, 1)`, `(B, H, W)`, `(H, W, 1)` o `(H, W)`.
masked_image_latents (`torch.Tensor`, `list[torch.Tensor]`) : `Tensor` que representa un lote de imágenes para enmascarar la `image` generada por el VAE. Si no se proporciona, el tensor de latentes de la máscara se generará mediante `mask_image`.
height (`int`, *opcional*, por defecto self.unet.config.sample_size * self.vae_scale_factor) : La altura en píxeles de la imagen generada. Por defecto, se establece en 1024 para obtener los mejores resultados.
width (`int`, *opcional*, por defecto self.unet.config.sample_size * self.vae_scale_factor) : El ancho en píxeles de la imagen generada. Por defecto, se establece en 1024 para obtener los mejores resultados.
padding_mask_crop (`int`, *opcional*, valor predeterminado `None`) : El tamaño del margen en el recorte que se aplicará a la imagen y la máscara. Si es `None`, no se aplica ningún recorte a la imagen y a mask_image. Si `padding_mask_crop` no es `None`, primero se buscará una región rectangular con la misma relación de aspecto que la imagen y que contenga toda el área enmascarada, y luego se expandirá esa área en función de `padding_mask_crop`. A continuación, la imagen y mask_image se recortarán según el área expandida antes de redimensionarlas al tamaño original de la imagen para el inpainting. Esto es útil cuando el área enmascarada es pequeña mientras que la imagen es grande y contiene información irrelevante para el inpainting, como el fondo.
strength (`float`, *opcional*, valor predeterminado 1.0) : Indica el grado en que se transforma la `image` de referencia. Debe estar entre 0 y 1. `image` se utiliza como punto de partida y se añade más ruido a medida que aumenta el `strength`. El número de pasos de desruido depende de la cantidad de ruido añadido inicialmente. Cuando `strength` es 1, el ruido añadido es máximo y el proceso de desruido se ejecuta durante el número completo de iteraciones especificado en `num_inference_steps`. Un valor de 1 ignora esencialmente `image`.
num_inference_steps (`int`, *opcional*, valor predeterminado 50) : 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.
sigmas (`list[float]`, *opcional*) : Sigmas personalizados para usar en el proceso de desruido con programadores que admiten un argumento `sigmas` en su método `set_timesteps`. Si no se define, se usará el comportamiento predeterminado cuando se pase `num_inference_steps`.
guidance_scale (`float`, *opcional*, valor predeterminado None) : Un valor de escala de guía para modelos destilados de guía. A diferencia de la guía libre de clasificador tradicional, donde la escala de guía se aplica durante la inferencia mediante el reescalado de la predicción de ruido, los modelos destilados de guía toman la escala de guía directamente como un parámetro de entrada durante la pasada hacia adelante. La escala de guía se habilita estableciendo `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. Este parámetro en el pipeline está presente para soportar futuros modelos destilados de guía cuando aparezcan. Se ignora cuando no se utilizan modelos destilados de guía. Para habilitar la guía libre de clasificador tradicional, pase `true_cfg_scale > 1.0` y `negative_prompt` (incluso un prompt negativo vacío como " " debería habilitar los cálculos de guía libre de clasificador).
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.
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_mask (`torch.Tensor`, *opcional*) : Máscara de atención para `prompt_embeds`.
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_mask (`torch.Tensor`, *opcional*) : Máscara de atención para `negative_prompt_embeds`.
output_type (`str`, *opcional*, por defecto `"pil"`) : El formato de salida de la imagen generada. Elija entre [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` o `np.array`.
return_dict (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe devolver un `~pipelines.qwenimage.QwenImagePipelineOutput` en lugar de una tupla simple.
attention_kwargs (`dict`, *opcional*) : Un diccionario de kwargs que, si se especifica, se pasa al `AttentionProcessor` tal como se define bajo `self.processor` en [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).
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.
max_sequence_length (`int` por defecto 512) : Longitud máxima de secuencia para usar con el `prompt`.
**Devuelve:** `~pipelines.qwenimage.QwenImagePipelineOutput` o `tuple`
`~pipelines.qwenimage.QwenImagePipelineOutput` 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 PIL import Image
>>> from diffusers import QwenImageEditInpaintPipeline
>>> from diffusers.utils import load_image
>>> pipe = QwenImageEditInpaintPipeline.from_pretrained("Qwen/Qwen-Image-Edit", torch_dtype=torch.bfloat16)
>>> pipe.to("cuda")
>>> prompt = "Face of a yellow cat, high resolution, sitting on a park bench"
>>> img_url = "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo.png"
>>> mask_url = "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo_mask.png"
>>> source = load_image(img_url)
>>> mask = load_image(mask_url)
>>> image = pipe(
... prompt=prompt, negative_prompt=" ", image=source, mask_image=mask, strength=1.0, num_inference_steps=50
... ).images[0]
>>> image.save("qwenimage_inpainting.png")
```
#### encode_prompt[[diffusers.QwenImageEditInpaintPipeline.encode_prompt]]
```python
encode_prompt(prompt: str | list[str], image: typing.Optional[torch.Tensor] = 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, max_sequence_length: int = 1024)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/qwenimage/pipeline_qwenimage_edit_inpaint.py#L284)
**Parámetros:**
prompt (`str` o `list[str]`, *opcional*) : prompt a codificar
image (`torch.Tensor`, *opcional*) : imagen a codificar
device : (`torch.device`): dispositivo de torch
num_images_per_prompt (`int`) : número de imágenes que deben generarse por prompt
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`.
## QwenImageControlNetPipeline[[diffusers.QwenImageControlNetPipeline]]
#### diffusers.QwenImageControlNetPipeline[[diffusers.QwenImageControlNetPipeline]]
```python
diffusers.QwenImageControlNetPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKLQwenImage, text_encoder: Qwen2_5_VLForConditionalGeneration, tokenizer: Qwen2Tokenizer, transformer: QwenImageTransformer2DModel, controlnet: diffusers.models.controlnets.controlnet_qwenimage.QwenImageControlNetModel | diffusers.models.controlnets.controlnet_qwenimage.QwenImageMultiControlNetModel)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/qwenimage/pipeline_qwenimage_controlnet.py#L192)
**Parámetros:**
transformer ([QwenImageTransformer2DModel](/docs/diffusers/main/es/api/models/qwenimage_transformer2d#diffusers.QwenImageTransformer2DModel)) : Arquitectura de Transformer condicional (MMDiT) para desruidar los latentes de imagen codificados.
scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/es/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Un programador para usar en combinación con `transformer` para desruidar los latentes de imagen codificados.
vae ([AutoencoderKL](/docs/diffusers/main/es/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modelo de Variational Auto-Encoder (VAE) para codificar y decodificar imágenes hacia y desde representaciones latentes.
text_encoder (`Qwen2.5-VL-7B-Instruct`) : [Qwen2.5-VL-7B-Instruct](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct), específicamente la variante [Qwen2.5-VL-7B-Instruct](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct).
tokenizer (`Qwen2Tokenizer`) : Tokenizador de la clase https://huggingface.co/docs/transformers/en/model_doc/qwen2#transformers.Qwen2Tokenizer
El pipeline QwenImage para la generación de imágenes a partir de texto.
#### __call__[[diffusers.QwenImageControlNetPipeline.__call__]]
```python
__call__(prompt: str | list[str] = None, negative_prompt: str | list[str] = None, true_cfg_scale: float = 4.0, height: int | None = None, width: int | None = None, num_inference_steps: int = 50, sigmas: list[float] | None = None, guidance_scale: float | None = None, control_guidance_start: float | list[float] = 0.0, control_guidance_end: float | list[float] = 1.0, control_image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]] = None, controlnet_conditioning_scale: float | list[float] = 1.0, 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], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/qwenimage/pipeline_qwenimage_controlnet.py#L511)
**Parámetros:**
prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar la generación de la imagen. Si no se define, se debe pasar `prompt_embeds` en su lugar.
negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (es decir, se ignora si `true_cfg_scale` no es mayor que `1`).
true_cfg_scale (`float`, *opcional*, valor predeterminado 1.0) : Escala de orientación definida en [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `true_cfg_scale` se define como `w` de la ecuación 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). La orientación libre de clasificador se habilita estableciendo `true_cfg_scale > 1` y proporcionando un `negative_prompt`. 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.
height (`int`, *opcional*, por defecto self.unet.config.sample_size * self.vae_scale_factor) : La altura en píxeles de la imagen generada. Por defecto, se establece en 1024 para obtener los mejores resultados.
width (`int`, *opcional*, por defecto self.unet.config.sample_size * self.vae_scale_factor) : El ancho en píxeles de la imagen generada. Por defecto, se establece en 1024 para obtener los mejores resultados.
num_inference_steps (`int`, *opcional*, valor predeterminado 50) : 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.
sigmas (`list[float]`, *opcional*) : Sigmas personalizados para usar en el proceso de desruido con programadores que admiten un argumento `sigmas` en su método `set_timesteps`. Si no se define, se usará el comportamiento predeterminado cuando se pase `num_inference_steps`.
guidance_scale (`float`, *opcional*, valor predeterminado None) : Un valor de escala de guía para modelos destilados de guía. A diferencia de la guía libre de clasificador tradicional, donde la escala de guía se aplica durante la inferencia mediante el reescalado de la predicción de ruido, los modelos destilados de guía toman la escala de guía directamente como un parámetro de entrada durante la pasada hacia adelante. La escala de guía se habilita estableciendo `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. Este parámetro en el pipeline está presente para soportar futuros modelos destilados de guía cuando aparezcan. Se ignora cuando no se utilizan modelos destilados de guía. Para habilitar la guía libre de clasificador tradicional, pase `true_cfg_scale > 1.0` y `negative_prompt` (incluso un prompt negativo vacío como " " debería habilitar los cálculos de guía libre de clasificador).
control_guidance_start (`float` o `list[float]`, *opcional*, valor predeterminado 0.0) : El porcentaje de pasos totales en el que ControlNet comienza a aplicarse.
control_guidance_end (`float` o `list[float]`, *opcional*, valor predeterminado 1.0) : El porcentaje de pasos totales en el que ControlNet deja de aplicarse.
control_image (`PipelineImageInput`, *opcional*) : La condición de entrada de ControlNet para proporcionar orientación a la generación.
controlnet_conditioning_scale (`float` o `list[float]`, *opcional*, valor predeterminado 1.0) : Las salidas del ControlNet se multiplican por `controlnet_conditioning_scale` antes de sumarse al residual en el `transformer` original.
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.
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_mask (`torch.Tensor`, *opcional*) : Máscara de atención para `prompt_embeds`.
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_mask (`torch.Tensor`, *opcional*) : Máscara de atención para `negative_prompt_embeds`.
output_type (`str`, *opcional*, por defecto `"pil"`) : El formato de salida de la imagen generada. Elija entre [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` o `np.array`.
return_dict (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe devolver un `~pipelines.qwenimage.QwenImagePipelineOutput` en lugar de una tupla simple.
attention_kwargs (`dict`, *opcional*) : Un diccionario de kwargs que, si se especifica, se pasa al `AttentionProcessor` tal como se define bajo `self.processor` en [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).
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.
max_sequence_length (`int` por defecto 512) : Longitud máxima de secuencia para usar con el `prompt`.
**Devuelve:** `~pipelines.qwenimage.QwenImagePipelineOutput` o `tuple`
`~pipelines.qwenimage.QwenImagePipelineOutput` 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.utils import load_image
>>> from diffusers import QwenImageControlNetModel, QwenImageMultiControlNetModel, QwenImageControlNetPipeline
>>> # QwenImageControlNetModel
>>> controlnet = QwenImageControlNetModel.from_pretrained(
... "InstantX/Qwen-Image-ControlNet-Union", torch_dtype=torch.bfloat16
... )
>>> pipe = QwenImageControlNetPipeline.from_pretrained(
... "Qwen/Qwen-Image", controlnet=controlnet, torch_dtype=torch.bfloat16
... )
>>> pipe.to("cuda")
>>> prompt = "Aesthetics art, traditional asian pagoda, elaborate golden accents, sky blue and white color palette, swirling cloud pattern, digital illustration, east asian architecture, ornamental rooftop, intricate detailing on building, cultural representation."
>>> negative_prompt = " "
>>> control_image = load_image(
... "https://huggingface.co/InstantX/Qwen-Image-ControlNet-Union/resolve/main/conds/canny.png"
... )
>>> # Depending on the variant being used, the pipeline call will slightly vary.
>>> # Refer to the pipeline documentation for more details.
>>> image = pipe(
... prompt,
... negative_prompt=negative_prompt,
... control_image=control_image,
... controlnet_conditioning_scale=1.0,
... num_inference_steps=30,
... true_cfg_scale=4.0,
... ).images[0]
>>> image.save("qwenimage_cn_union.png")
>>> # QwenImageMultiControlNetModel
>>> controlnet = QwenImageControlNetModel.from_pretrained(
... "InstantX/Qwen-Image-ControlNet-Union", torch_dtype=torch.bfloat16
... )
>>> controlnet = QwenImageMultiControlNetModel([controlnet])
>>> pipe = QwenImageControlNetPipeline.from_pretrained(
... "Qwen/Qwen-Image", controlnet=controlnet, torch_dtype=torch.bfloat16
... )
>>> pipe.to("cuda")
>>> prompt = "Aesthetics art, traditional asian pagoda, elaborate golden accents, sky blue and white color palette, swirling cloud pattern, digital illustration, east asian architecture, ornamental rooftop, intricate detailing on building, cultural representation."
>>> negative_prompt = " "
>>> control_image = load_image(
... "https://huggingface.co/InstantX/Qwen-Image-ControlNet-Union/resolve/main/conds/canny.png"
... )
>>> # Depending on the variant being used, the pipeline call will slightly vary.
>>> # Refer to the pipeline documentation for more details.
>>> image = pipe(
... prompt,
... negative_prompt=negative_prompt,
... control_image=[control_image, control_image],
... controlnet_conditioning_scale=[0.5, 0.5],
... num_inference_steps=30,
... true_cfg_scale=4.0,
... ).images[0]
>>> image.save("qwenimage_cn_union_multi.png")
```
#### encode_prompt[[diffusers.QwenImageControlNetPipeline.encode_prompt]]
```python
encode_prompt(prompt: str | list[str], 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, max_sequence_length: int = 1024)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/qwenimage/pipeline_qwenimage_controlnet.py#L290)
**Parámetros:**
prompt (`str` o `list[str]`, *opcional*) : prompt a codificar
device : (`torch.device`): dispositivo de torch
num_images_per_prompt (`int`) : número de imágenes que deben generarse por prompt
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`.
## QwenImageEditPlusPipeline[[diffusers.QwenImageEditPlusPipeline]]
#### diffusers.QwenImageEditPlusPipeline[[diffusers.QwenImageEditPlusPipeline]]
```python
diffusers.QwenImageEditPlusPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKLQwenImage, text_encoder: Qwen2_5_VLForConditionalGeneration, tokenizer: Qwen2Tokenizer, processor: Qwen2VLProcessor, transformer: QwenImageTransformer2DModel)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/qwenimage/pipeline_qwenimage_edit_plus.py#L168)
**Parámetros:**
transformer ([QwenImageTransformer2DModel](/docs/diffusers/main/es/api/models/qwenimage_transformer2d#diffusers.QwenImageTransformer2DModel)) : Arquitectura de Transformer condicional (MMDiT) para desruidar los latentes de imagen codificados.
scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/es/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Un programador para usar en combinación con `transformer` para desruidar los latentes de imagen codificados.
vae ([AutoencoderKL](/docs/diffusers/main/es/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modelo de Variational Auto-Encoder (VAE) para codificar y decodificar imágenes hacia y desde representaciones latentes.
text_encoder (`Qwen2.5-VL-7B-Instruct`) : [Qwen2.5-VL-7B-Instruct](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct), específicamente la variante [Qwen2.5-VL-7B-Instruct](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct).
tokenizer (`Qwen2Tokenizer`) : Tokenizador de la clase https://huggingface.co/docs/transformers/en/model_doc/qwen2#transformers.Qwen2Tokenizer
El pipeline Qwen-Image-Edit para la edición de imágenes.
#### __call__[[diffusers.QwenImageEditPlusPipeline.__call__]]
```python
__call__(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, prompt: str | list[str] = None, negative_prompt: str | list[str] = None, true_cfg_scale: float = 4.0, height: int | None = None, width: int | None = None, num_inference_steps: int = 50, sigmas: list[float] | None = None, guidance_scale: 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], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/qwenimage/pipeline_qwenimage_edit_plus.py#L526)
**Parámetros:**
image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]` o `list[np.ndarray]`) : `Image`, array de numpy o tensor que representa un lote de imágenes para usarse como punto de partida. Tanto para arrays de numpy como para tensors de PyTorch, el rango de valores esperado está entre `[0, 1]`. Si es un tensor o una lista de tensors, la forma esperada debe ser `(B, C, H, W)` o `(C, H, W)`. Si es un array de numpy o una lista de arrays, la forma esperada debe ser `(B, H, W, C)` o `(H, W, C)`. También puede aceptar latentes de imagen como `image`, pero si se pasan latentes directamente, no se vuelven a codificar.
prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar la generación de la imagen. Si no se define, se debe pasar `prompt_embeds` en su lugar.
negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (es decir, se ignora si `true_cfg_scale` no es mayor que `1`).
true_cfg_scale (`float`, *opcional*, valor predeterminado 1.0) : true_cfg_scale (`float`, *opcional*, valor predeterminado 1.0): Escala de guía definida en [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `true_cfg_scale` se define como `w` de la ecuación 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). La guía sin clasificador se habilita estableciendo `true_cfg_scale > 1` y proporcionando un `negative_prompt`. 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.
height (`int`, *opcional*, por defecto self.unet.config.sample_size * self.vae_scale_factor) : La altura en píxeles de la imagen generada. Por defecto, se establece en 1024 para obtener los mejores resultados.
width (`int`, *opcional*, por defecto self.unet.config.sample_size * self.vae_scale_factor) : El ancho en píxeles de la imagen generada. Por defecto, se establece en 1024 para obtener los mejores resultados.
num_inference_steps (`int`, *opcional*, valor predeterminado 50) : 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.
sigmas (`list[float]`, *opcional*) : Sigmas personalizados para usar en el proceso de desruido con programadores que admiten un argumento `sigmas` en su método `set_timesteps`. Si no se define, se usará el comportamiento predeterminado cuando se pase `num_inference_steps`.
guidance_scale (`float`, *opcional*, valor predeterminado None) : Un valor de escala de guía para modelos destilados de guía. A diferencia de la guía libre de clasificador tradicional, donde la escala de guía se aplica durante la inferencia mediante el reescalado de la predicción de ruido, los modelos destilados de guía toman la escala de guía directamente como un parámetro de entrada durante la pasada hacia adelante. La escala de guía se habilita estableciendo `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. Este parámetro en el pipeline está presente para soportar futuros modelos destilados de guía cuando aparezcan. Se ignora cuando no se utilizan modelos destilados de guía. Para habilitar la guía libre de clasificador tradicional, pase `true_cfg_scale > 1.0` y `negative_prompt` (incluso un prompt negativo vacío como " " debería habilitar los cálculos de guía libre de clasificador).
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.
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_mask (`torch.Tensor`, *opcional*) : Máscara de atención para `prompt_embeds`.
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_mask (`torch.Tensor`, *opcional*) : Máscara de atención para `negative_prompt_embeds`.
output_type (`str`, *opcional*, por defecto `"pil"`) : El formato de salida de la imagen generada. Elija entre [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` o `np.array`.
return_dict (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe devolver un `~pipelines.qwenimage.QwenImagePipelineOutput` en lugar de una tupla simple.
attention_kwargs (`dict`, *opcional*) : Un diccionario de kwargs que, si se especifica, se pasa al `AttentionProcessor` tal como se define bajo `self.processor` en [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).
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.
max_sequence_length (`int` por defecto 512) : Longitud máxima de secuencia para usar con el `prompt`.
**Devuelve:** `~pipelines.qwenimage.QwenImagePipelineOutput` o `tuple`
`~pipelines.qwenimage.QwenImagePipelineOutput` 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 PIL import Image
>>> from diffusers import QwenImageEditPlusPipeline
>>> from diffusers.utils import load_image
>>> pipe = QwenImageEditPlusPipeline.from_pretrained("Qwen/Qwen-Image-Edit-2509", torch_dtype=torch.bfloat16)
>>> pipe.to("cuda")
>>> image = load_image(
... "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/yarn-art-pikachu.png"
... ).convert("RGB")
>>> prompt = (
... "Make Pikachu hold a sign that says 'Qwen Edit is awesome', yarn art style, detailed, vibrant colors"
... )
>>> # Depending on the variant being used, the pipeline call will slightly vary.
>>> # Refer to the pipeline documentation for more details.
>>> image = pipe(image, prompt, num_inference_steps=50).images[0]
>>> image.save("qwenimage_edit_plus.png")
```
#### encode_prompt[[diffusers.QwenImageEditPlusPipeline.encode_prompt]]
```python
encode_prompt(prompt: str | list[str], image: typing.Optional[torch.Tensor] = 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, max_sequence_length: int = 1024)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/qwenimage/pipeline_qwenimage_edit_plus.py#L286)
**Parámetros:**
prompt (`str` o `list[str]`, *opcional*) : prompt a codificar
image (`torch.Tensor`, *opcional*) : imagen a codificar
device : (`torch.device`): dispositivo de torch
num_images_per_prompt (`int`) : número de imágenes que deben generarse por prompt
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`.
## QwenImageLayeredPipeline[[diffusers.QwenImageLayeredPipeline]]
#### diffusers.QwenImageLayeredPipeline[[diffusers.QwenImageLayeredPipeline]]
```python
diffusers.QwenImageLayeredPipeline(scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKLQwenImage, text_encoder: Qwen2_5_VLForConditionalGeneration, tokenizer: Qwen2Tokenizer, processor: Qwen2VLProcessor, transformer: QwenImageTransformer2DModel)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/qwenimage/pipeline_qwenimage_layered.py#L174)
**Parámetros:**
transformer ([QwenImageTransformer2DModel](/docs/diffusers/main/es/api/models/qwenimage_transformer2d#diffusers.QwenImageTransformer2DModel)) : Arquitectura de Transformer condicional (MMDiT) para desruidar los latentes de imagen codificados.
scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/main/es/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Un programador para usar en combinación con `transformer` para desruidar los latentes de imagen codificados.
vae ([AutoencoderKL](/docs/diffusers/main/es/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Modelo de Variational Auto-Encoder (VAE) para codificar y decodificar imágenes hacia y desde representaciones latentes.
text_encoder (`Qwen2.5-VL-7B-Instruct`) : [Qwen2.5-VL-7B-Instruct](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct), específicamente la variante [Qwen2.5-VL-7B-Instruct](https://huggingface.co/Qwen/Qwen2.5-VL-7B-Instruct).
tokenizer (`Qwen2Tokenizer`) : Tokenizador de la clase https://huggingface.co/docs/transformers/en/model_doc/qwen2#transformers.Qwen2Tokenizer
El pipeline Qwen-Image-Layered para la descomposición de imágenes.
#### __call__[[diffusers.QwenImageLayeredPipeline.__call__]]
```python
__call__(image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, prompt: str | list[str] = None, negative_prompt: str | list[str] = None, true_cfg_scale: float = 4.0, layers: int | None = 4, num_inference_steps: int = 50, sigmas: list[float] | None = None, guidance_scale: 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], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 512, resolution: int = 640, cfg_normalize: bool = False, use_en_prompt: bool = False)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/qwenimage/pipeline_qwenimage_layered.py#L537)
**Parámetros:**
image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]` o `list[np.ndarray]`) : `Image`, array de numpy o tensor que representa un lote de imágenes para usarse como punto de partida. Tanto para arrays de numpy como para tensors de PyTorch, el rango de valores esperado está entre `[0, 1]`. Si es un tensor o una lista de tensors, la forma esperada debe ser `(B, C, H, W)` o `(C, H, W)`. Si es un array de numpy o una lista de arrays, la forma esperada debe ser `(B, H, W, C)` o `(H, W, C)`. También puede aceptar latentes de imagen como `image`, pero si se pasan latentes directamente, no se vuelven a codificar.
prompt (`str` o `list[str]`, *opcional*) : El prompt o los prompts para guiar la generación de la imagen. Si no se define, se debe pasar `prompt_embeds` en su lugar.
negative_prompt (`str` o `list[str]`, *opcional*) : El prompt o prompts que no deben guiar la generación de la imagen. Si no se define, se debe pasar `negative_prompt_embeds` en su lugar. Se ignora cuando no se usa guía (es decir, se ignora si `true_cfg_scale` no es mayor que `1`).
true_cfg_scale (`float`, *opcional*, valor predeterminado 1.0) : true_cfg_scale (`float`, *opcional*, valor predeterminado 1.0): Escala de guía definida en [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `true_cfg_scale` se define como `w` de la ecuación 2. de [Imagen Paper](https://huggingface.co/papers/2205.11487). La guía sin clasificador se habilita estableciendo `true_cfg_scale > 1` y proporcionando un `negative_prompt`. 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.
layers (`int`, *opcional*, valor predeterminado 4) : Número de capas latentes a generar para la salida por capas.
num_inference_steps (`int`, *opcional*, valor predeterminado 50) : 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.
sigmas (`list[float]`, *opcional*) : Sigmas personalizados para usar en el proceso de desruido con programadores que admiten un argumento `sigmas` en su método `set_timesteps`. Si no se define, se usará el comportamiento predeterminado cuando se pase `num_inference_steps`.
guidance_scale (`float`, *opcional*, valor predeterminado None) : Un valor de escala de guía para modelos destilados de guía. A diferencia de la guía libre de clasificador tradicional, donde la escala de guía se aplica durante la inferencia mediante el reescalado de la predicción de ruido, los modelos destilados de guía toman la escala de guía directamente como un parámetro de entrada durante la pasada hacia adelante. La escala de guía se habilita estableciendo `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. Este parámetro en el pipeline está presente para soportar futuros modelos destilados de guía cuando aparezcan. Se ignora cuando no se utilizan modelos destilados de guía. Para habilitar la guía libre de clasificador tradicional, pase `true_cfg_scale > 1.0` y `negative_prompt` (incluso un prompt negativo vacío como " " debería habilitar los cálculos de guía libre de clasificador).
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.
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_mask (`torch.Tensor`, *opcional*) : Máscara de atención para `prompt_embeds`.
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_mask (`torch.Tensor`, *opcional*) : Máscara de atención para `negative_prompt_embeds`.
output_type (`str`, *opcional*, por defecto `"pil"`) : El formato de salida de la imagen generada. Elija entre [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` o `np.array`.
return_dict (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe devolver un `~pipelines.qwenimage.QwenImagePipelineOutput` en lugar de una tupla simple.
attention_kwargs (`dict`, *opcional*) : Un diccionario de kwargs que, si se especifica, se pasa al `AttentionProcessor` tal como se define bajo `self.processor` en [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).
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.
max_sequence_length (`int` por defecto 512) : Longitud máxima de secuencia para usar con el `prompt`.
resolution (`int`, *opcional*, valor predeterminado 640) : usar un bucket diferente en (640, 1024) para determinar la resolución de la condición y la salida
cfg_normalize (`bool`, *opcional*, por defecto `False`) : si se habilita la normalización de cfg.
use_en_prompt (`bool`, *opcional*, por defecto `False`) : idioma automático de la descripción si el usuario no proporciona una
**Devuelve:** `~pipelines.qwenimage.QwenImagePipelineOutput` o `tuple`
`~pipelines.qwenimage.QwenImagePipelineOutput` 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 PIL import Image
>>> from diffusers import QwenImageLayeredPipeline
>>> from diffusers.utils import load_image
>>> pipe = QwenImageLayeredPipeline.from_pretrained("Qwen/Qwen-Image-Layered", torch_dtype=torch.bfloat16)
>>> pipe.to("cuda")
>>> image = load_image(
... "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/yarn-art-pikachu.png"
... ).convert("RGBA")
>>> prompt = ""
>>> # Depending on the variant being used, the pipeline call will slightly vary.
>>> # Refer to the pipeline documentation for more details.
>>> images = pipe(
... image,
... prompt,
... num_inference_steps=50,
... true_cfg_scale=4.0,
... layers=4,
... resolution=640,
... cfg_normalize=False,
... use_en_prompt=True,
... ).images[0]
>>> for i, image in enumerate(images):
... image.save(f"{i}.out.png")
```
#### encode_prompt[[diffusers.QwenImageLayeredPipeline.encode_prompt]]
```python
encode_prompt(prompt: str | list[str], 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, max_sequence_length: int = 1024)
```
[Fuente](https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/qwenimage/pipeline_qwenimage_layered.py#L291)
**Parámetros:**
prompt (`str` o `list[str]`, *opcional*) : prompt a codificar
device : (`torch.device`): dispositivo de torch
num_images_per_prompt (`int`) : número de imágenes que deben generarse por prompt
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`.
## 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.
#
# Bajo licencia Apache License, versión 2.0 (la "Licencia");
# no puede usar este archivo excepto en cumplimiento de la Licencia.
# Puede obtener una copia de la Licencia en
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# A menos que la ley aplicable lo exija o se haya acordado por escrito, el software
# distribuido bajo la Licencia se distribuye en una base "TAL CUAL",
# SIN GARANTÍAS NI CONDICIONES DE NINGÚN TIPO, ya sea expresa o implícita.
# Consulte la Licencia para el lenguaje específico que rige los permisos y
# limitaciones de la Licencia. -->
# QwenImage
Qwen-Image, del equipo Qwen, es un modelo base de generación de imágenes de la serie Qwen que logra avances significativos en el renderizado de texto complejo y la edición precisa de imágenes. Los experimentos muestran capacidades generales sólidas tanto en la generación como en la edición de imágenes, con un rendimiento excepcional en el renderizado de texto, especialmente para el chino.
Qwen-Image está disponible en las siguientes variantes:
| tipo de modelo | id del modelo |
|:----------:|:--------:|
| Qwen-Image | [`Qwen/Qwen-Image`](https://huggingface.co/Qwen/Qwen-Image) |
| Qwen-Image-Edit | [`Qwen/Qwen-Image-Edit`](https://huggingface.co/Qwen/Qwen-Image-Edit) |
| Qwen-Image-Edit Plus | [Qwen/Qwen-Image-Edit-2509](https://huggingface.co/Qwen/Qwen-Image-Edit-2509) |
> [!TIP]
> Consulte la guía de [Caching](../../optimization/cache) para acelerar la inferencia almacenando y reutilizando salidas intermedias.
## LoRA para una inferencia más rápida
Usa un LoRA de `lightx2v/Qwen-Image-Lightning` para acelerar la inferencia reduciendo el número de pasos. Consulta el fragmento de código a continuación:
Código
```py
from diffusers import DiffusionPipeline, FlowMatchEulerDiscreteScheduler
import torch
import math
ckpt_id = "Qwen/Qwen-Image"
# From
# https://github.com/ModelTC/Qwen-Image-Lightning/blob/342260e8f5468d2f24d084ce04f55e101007118b/generate_with_diffusers.py#L82C9-L97C10
scheduler_config = {
"base_image_seq_len": 256,
"base_shift": math.log(3), # We use shift=3 in distillation
"invert_sigmas": False,
"max_image_seq_len": 8192,
"max_shift": math.log(3), # We use shift=3 in distillation
"num_train_timesteps": 1000,
"shift": 1.0,
"shift_terminal": None, # set shift_terminal to None
"stochastic_sampling": False,
"time_shift_type": "exponential",
"use_beta_sigmas": False,
"use_dynamic_shifting": True,
"use_exponential_sigmas": False,
"use_karras_sigmas": False,
}
scheduler = FlowMatchEulerDiscreteScheduler.from_config(scheduler_config)
pipe = DiffusionPipeline.from_pretrained(
ckpt_id, scheduler=scheduler, dtype=torch.bfloat16
).to("cuda") # or "mps", "xpu", "cpu"
pipe.load_lora_weights(
"lightx2v/Qwen-Image-Lightning", weight_name="Qwen-Image-Lightning-8steps-V1.0.safetensors"
)
prompt = "a tiny astronaut hatching from an egg on the moon, Ultra HD, 4K, cinematic composition."
negative_prompt = " "
image = pipe(
prompt=prompt,
negative_prompt=negative_prompt,
width=1024,
height=1024,
num_inference_steps=8,
true_cfg_scale=1.0,
generator=torch.manual_seed(0),
).images[0]
image.save("qwen_fewsteps.png")
```
> [!TIP]
> El parámetro `guidance_scale` en el pipeline está ahí para soportar futuros modelos destilados con guía cuando aparezcan. Tenga en cuenta que pasar `guidance_scale` al pipeline no tiene efecto. Para habilitar la guía sin clasificador, pase `true_cfg_scale` y `negative_prompt` (incluso un prompt negativo vacío como " ") debería habilitar los cálculos de guía sin clasificador.
## Referencia de múltiples imágenes con QwenImageEditPlusPipeline
Con [QwenImageEditPlusPipeline](/docs/diffusers/main/es/api/pipelines/qwenimage#diffusers.QwenImageEditPlusPipeline), se pueden proporcionar varias imágenes como referencia de entrada.
```py
import torch
from PIL import Image
from diffusers import QwenImageEditPlusPipeline
from diffusers.utils import load_image
pipe = QwenImageEditPlusPipeline.from_pretrained(
"Qwen/Qwen-Image-Edit-2509", dtype=torch.bfloat16
).to("cuda") # or "mps", "xpu", "cpu"
Xet Storage Details
- Size:
- 109 kB
- Xet hash:
- 42aa099bdc0cecd3b6a92de12df98443e358356cc7f2a4b9ebd4bc3ce58037ce
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.