> ## Documentation Index
> Fetch the complete documentation index at: https://docs.comfy.org/llms.txt
> Use this file to discover all available pages before exploring further.

# Ejemplo de flujo de trabajo nativo de Qwen-Image en ComfyUI

> Qwen-Image es un modelo MMDiT (Multimodal Diffusion Transformer) de 20B parámetros, de código abierto bajo la licencia Apache 2.0.

**Qwen-Image** es el primer modelo fundacional de generación de imágenes publicado por el equipo Qwen de Alibaba. Es un modelo MMDiT (Multimodal Diffusion Transformer) de 20B de parámetros, de código abierto bajo la licencia Apache 2.0. El modelo ha logrado avances significativos en el **renderizado de texto complejo** y la **edición precisa de imágenes**, alcanzando una salida de alta fidelidad en varios idiomas, incluidos el inglés y el chino.

**Aspectos destacados del modelo**:

* **Excelente renderizado de texto multilingüe**: admite la generación de texto de alta precisión en varios idiomas, incluidos inglés, chino, coreano y japonés, manteniendo los detalles tipográficos y la consistencia del diseño
* **Estilos artísticos diversos**: desde escenas fotorrealistas hasta pinturas impresionistas, desde la estética anime hasta el diseño minimalista, adaptándose con fluidez a distintos prompts creativos

**Enlaces relacionados**:

* [GitHub](https://github.com/QwenLM/Qwen-Image)
* [Hugging Face](https://huggingface.co/Qwen/Qwen-Image)
* [ModelScope](https://modelscope.cn/models/qwen/Qwen-Image)

Actualmente, Qwen-Image tiene disponibles varias opciones de soporte para ControlNet:

* [Qwen-Image-DiffSynth-ControlNets/model\_patches](https://huggingface.co/Comfy-Org/Qwen-Image-DiffSynth-ControlNets/tree/main/split_files/model_patches): incluye modelos canny, de profundidad e inpaint
* [qwen\_image\_union\_diffsynth\_lora.safetensors](https://huggingface.co/Comfy-Org/Qwen-Image-DiffSynth-ControlNets/blob/main/split_files/loras/qwen_image_union_diffsynth_lora.safetensors): LoRA de control de la estructura de la imagen compatible con canny, profundidad, pose, arte lineal, softedge, normal y openpose
* InstantX ControlNet: pendiente de actualización

## Transmisión en vivo de Qwen-Image de ComfyOrg

**Qwen-Image en ComfyUI: Lightning y LoRAs**

[Qwen-Image en ComfyUI: Lightning y LoRAs / 15 de agosto de 2025](https://www.youtube.com/embed/WBFHwrpYRtY?si=uREGRhBDryTJBIry)

**Qwen-Image ControlNet en ComfyUI: DiffSynth**

[Qwen-Image ControlNet en ComfyUI: DiffSynth / 26 de agosto de 2025](https://www.youtube.com/embed/bXMClHfEFn4?si=dcaNdqOMSwvu3t8x)

## Ejemplo de flujo de trabajo nativo de Qwen-Image

> [!TIP]
>
> **Usuarios locales**
>
> Asegúrate de que tu ComfyUI esté actualizado.
>
> * [Descargar ComfyUI](https://www.comfy.org/download)
> * [Guía de actualización](https://docs.comfy.org/es/installation/update_comfyui.md)
>
> Los flujos de trabajo de esta guía se encuentran en las [Plantillas de flujos de trabajo](https://docs.comfy.org/es/interface/features/template.md).
> Si no los encuentras en las plantillas, es posible que tu ComfyUI esté desactualizado.
>
> Si faltan nodos al cargar un flujo de trabajo, estas son las posibles razones:
>
> 1. No estás usando la última versión de ComfyUI (versión nocturna)
> 2. Algunos nodos fallaron al importarse durante el inicio
>
> **Usuarios de Cloud**
>
> * [Cloud](https://cloud.comfy.org) se actualizará después del lanzamiento estable de ComfyUI.
>
> Por lo tanto, si notas que falta algún nodo central en este documento, puede deberse a que los nuevos nodos centrales aún no se han publicado en la última versión estable. Espera al próximo lanzamiento estable.

### Qwen-Image: Texto a imagen

Genera imágenes con capacidades excepcionales de renderizado y edición de texto multilingüe usando el modelo MMDiT de 20B de Qwen-Image.

![Vista previa del flujo de trabajo de texto a imagen de Qwen-Image](https://raw.githubusercontent.com/Comfy-Org/workflow_templates/main/templates/image_qwen_image-1.webp)

> **[Ejecutar en Comfy Cloud](https://cloud.comfy.org/?template=image_qwen_image\&utm_source=docs\&utm_medium=referral\&utm_campaign=qwen-image)**
>
> Abrir en Comfy Cloud

> **[Descargar flujo de trabajo](https://github.com/Comfy-Org/workflow_templates/blob/main/templates/image_qwen_image.json)**
>
> Descarga el JSON o busca "Qwen-Image" en la Biblioteca de plantillas

**Salida de ejemplo**

![Salida de ejemplo de Qwen-Image](https://raw.githubusercontent.com/Comfy-Org/workflow_templates/main/output/image_qwen_image.png)

En el flujo de trabajo que acompaña a este documento se usan tres modelos diferentes:

1. Modelo original Qwen-Image fp8\_e4m3fn
2. Versión acelerada de 8 pasos: modelo original Qwen-Image fp8\_e4m3fn con el LoRA de 8 pasos de lightx2v
3. Versión destilada: modelo destilado Qwen-Image fp8\_e4m3fn

**Referencia de uso de VRAM**
GPU: RTX4090D 24GB

| Modelo utilizado | Uso de VRAM | Primera generación | Segunda generación |
| - | - | - | - |
| fp8\_e4m3fn | 86% | ≈ 94s | ≈ 71s |
| fp8\_e4m3fn con el LoRA de 8 pasos de lightx2v | 86% | ≈ 55s | ≈ 34s |
| fp8\_e4m3fn destilado | 86% | ≈ 69s | ≈ 36s |

### 1. Archivo del flujo de trabajo

Después de actualizar ComfyUI, puedes encontrar el archivo del flujo de trabajo en las plantillas, o arrastrar el flujo de trabajo que aparece a continuación a ComfyUI para cargarlo.
![Flujo de trabajo de texto a imagen de Qwen-Image](https://raw.githubusercontent.com/Comfy-Org/example_workflows/main/image/qwen/qwen-image.png)

Versión destilada

> **[Descargar flujo de trabajo para el modelo destilado](https://github.com/Comfy-Org/example_workflows/blob/main/image/qwen/image_qwen_image_distill.json)**
>
> Descargar flujo de trabajo JSON

### 2. Descarga de modelos

**Modelos disponibles en ComfyUI**

* Qwen-Image\_bf16 (40.9 GB)
* Qwen-Image\_fp8 (20.4 GB)
* Versiones destiladas (no oficiales, solo requieren 15 pasos)

Todos los modelos están disponibles en [Huggingface](https://huggingface.co/Comfy-Org/Qwen-Image_ComfyUI/tree/main) y [Modelscope](https://modelscope.cn/models/Comfy-Org/Qwen-Image_ComfyUI/files)

**Modelo de difusión**

* [qwen\_image\_fp8\_e4m3fn.safetensors](https://huggingface.co/Comfy-Org/Qwen-Image_ComfyUI/blob/main/split_files/diffusion_models/qwen_image_fp8_e4m3fn.safetensors)

Qwen\_image\_distill

* [qwen\_image\_distill\_full\_fp8\_e4m3fn.safetensors](https://huggingface.co/Comfy-Org/Qwen-Image_ComfyUI/blob/main/non_official/diffusion_models/qwen_image_distill_full_fp8_e4m3fn.safetensors)
* [qwen\_image\_distill\_full\_bf16.safetensors](https://huggingface.co/Comfy-Org/Qwen-Image_ComfyUI/blob/main/non_official/diffusion_models/qwen_image_distill_full_bf16.safetensors)

> [!NOTE]
>
> * El autor original de la versión destilada recomienda usar 15 pasos con cfg 1.0.
> * Según las pruebas, esta versión destilada también funciona bien con 10 pasos y cfg 1.0. Puedes elegir euler o res\_multistep según el tipo de imagen que quieras.

**LoRA**

* [Qwen-Image-Lightning-8steps-V1.0.safetensors](https://huggingface.co/lightx2v/Qwen-Image-Lightning/blob/main/Qwen-Image-Lightning-8steps-V1.0.safetensors)

**Codificador de texto**

* [qwen\_2.5\_vl\_7b\_fp8\_scaled.safetensors](https://huggingface.co/Comfy-Org/Qwen-Image_ComfyUI/blob/main/split_files/text_encoders/qwen_2.5_vl_7b_fp8_scaled.safetensors)

**VAE**

[qwen\_image\_vae.safetensors](https://huggingface.co/Comfy-Org/Qwen-Image_ComfyUI/blob/main/split_files/vae/qwen_image_vae.safetensors)

**Ubicación de almacenamiento de los modelos**

```
📂 ComfyUI/
├── 📂 models/
│   ├── 📂 diffusion_models/
│   │   ├── qwen_image_fp8_e4m3fn.safetensors
│   │   └── qwen_image_distill_full_fp8_e4m3fn.safetensors ## versión destilada
│   ├── 📂 loras/
│   │   └── Qwen-Image-Lightning-8steps-V1.0.safetensors   ## modelo LoRA de aceleración de 8 pasos
│   ├── 📂 vae/
│   │   └── qwen_image_vae.safetensors
│   └── 📂 text_encoders/
│       └── qwen_2.5_vl_7b_fp8_scaled.safetensors
```

### 3. Instrucciones del flujo de trabajo

![Guía paso a paso](https://mintcdn.com/dripart/SIDaLac8vBogzwm7/images/tutorial/image/qwen/image_qwen_image-guide.jpg?fit=max\&auto=format\&n=SIDaLac8vBogzwm7\&q=85\&s=123e11f9be1c31a9e3a3c0ff1df299da)

1. Asegúrate de que el nodo `Load Diffusion Model` haya cargado `qwen_image_fp8_e4m3fn.safetensors`
2. Asegúrate de que el nodo `Load CLIP` haya cargado `qwen_2.5_vl_7b_fp8_scaled.safetensors`
3. Asegúrate de que el nodo `Load VAE` haya cargado `qwen_image_vae.safetensors`
4. Asegúrate de que el nodo `EmptySD3LatentImage` tenga configuradas las dimensiones de imagen correctas
5. Configura tu prompt en el nodo `CLIP Text Encoder`; actualmente admite al menos inglés, chino, coreano, japonés, italiano, etc.
6. Si quieres habilitar el LoRA de aceleración de 8 pasos de lightx2v, selecciona el nodo y usa `Ctrl + B` para habilitarlo, y modifica las configuraciones del KSampler como se describe en el paso 8
7. Haz clic en el botón `Queue`, o usa el atajo `Ctrl(cmd) + Enter` para ejecutar el flujo de trabajo
8. Para las diferentes versiones de modelos y flujos de trabajo, ajusta los parámetros del KSampler en consecuencia

> [!NOTE]
>
> El modelo destilado y el LoRA de aceleración de 8 pasos de lightx2v no parecen ser compatibles para usarlos de forma simultánea. Puedes probar distintas combinaciones para comprobar si funcionan juntos.

## Flujo de trabajo con ControlNet InstantX de Qwen Image

Este es un modelo ControlNet, así que puedes usarlo como un ControlNet normal.

### Qwen-Image InstantX Union ControlNet

Genera imágenes con Qwen-Image InstantX ControlNet, compatible con canny, soft edge, profundidad y pose.

![Vista previa del flujo de trabajo con Qwen-Image InstantX ControlNet](https://raw.githubusercontent.com/Comfy-Org/workflow_templates/main/templates/image_qwen_image_instantx_controlnet-1.webp)

> **[Ejecutar en Comfy Cloud](https://cloud.comfy.org/?template=image_qwen_image_instantx_controlnet\&utm_source=docs\&utm_medium=referral\&utm_campaign=qwen-image)**
>
> Abrir en Comfy Cloud

> **[Descargar flujo de trabajo](https://github.com/Comfy-Org/workflow_templates/blob/main/templates/image_qwen_image_instantx_controlnet.json)**
>
> Descarga el JSON o busca "Qwen-Image InstantX ControlNet" en la Biblioteca de plantillas

**Materiales de entrada**

Sube este archivo al nodo `LoadImage` correspondiente:

> **[image\_qwen\_image\_instantx\_controlnet\_input\_image.jpg](https://raw.githubusercontent.com/Comfy-Org/workflow_templates/main/input/image_qwen_image_instantx_controlnet_input_image.jpg)**
>
> Nodo `LoadImage` 71 · `image_qwen_image_instantx_controlnet_input_image.jpg`

![image\_qwen\_image\_instantx\_controlnet\_input\_image.jpg](https://raw.githubusercontent.com/Comfy-Org/workflow_templates/main/input/image_qwen_image_instantx_controlnet_input_image.jpg)

## 1. Flujo de trabajo e imágenes de entrada

### 2. Enlaces a los modelos

1. InstantX Controlnet

Descarga [Qwen-Image-InstantX-ControlNet-Union.safetensors](https://huggingface.co/Comfy-Org/Qwen-Image-InstantX-ControlNets/blob/main/split_files/controlnet/Qwen-Image-InstantX-ControlNet-Union.safetensors) y guárdalo en la carpeta `ComfyUI/models/controlnet/`

2. **Modelo Lotus Depth**

Usaremos este modelo para generar el mapa de profundidad de la imagen. Es necesario descargar los siguientes dos modelos:

**Modelo de difusión**

* [lotus-depth-d-v1-1.safetensors](https://huggingface.co/Comfy-Org/lotus/blob/main/lotus-depth-d-v1-1.safetensors)

**Modelo VAE**

* [vae-ft-mse-840000-ema-pruned.safetensors](https://huggingface.co/stabilityai/sd-vae-ft-mse-original/blob/main/vae-ft-mse-840000-ema-pruned.safetensors) o cualquier VAE de SD1.5

```
ComfyUI/
├── models/
│   ├── diffusion_models/
│   │   └─── lotus-depth-d-v1-1.safetensors
│   └── vae/
│       └──  lvae-ft-mse-840000-ema-pruned.safetensors
```

> También puedes usar Nodos personalizados como [comfyui\_controlnet\_aux](https://github.com/Fannovel16/comfyui_controlnet_aux) para generar el mapa de profundidad.

### 3. Instrucciones del flujo de trabajo

![Instrucciones del proceso](https://mintcdn.com/dripart/SIDaLac8vBogzwm7/images/tutorial/image/qwen/image_qwen_image_instantx_controlnet.jpg?fit=max\&auto=format\&n=SIDaLac8vBogzwm7\&q=85\&s=a73a3f375691a80eb87a6cec12c48ad9)

1. Asegúrate de que el nodo `Load ControlNet Model` cargue correctamente el modelo `Qwen-Image-InstantX-ControlNet-Union.safetensors`
2. Sube la imagen de entrada
3. Este subgrafo usa el modelo Lotus Depth. Puedes encontrarlo en las Plantillas o editar el subgrafo para aprender más; asegúrate de que todos los modelos estén cargados correctamente
4. Haz clic en el botón `Run`, o usa el atajo `Ctrl(cmd) + Enter` para ejecutar el flujo de trabajo

## Flujo de trabajo de parches de modelo ControlNet DiffSynth-ControlNets para Qwen Image

### Parche de modelo ControlNet de Qwen-Image

Controla la generación de imágenes con modelos ControlNet de Qwen-Image. Compatible con los controles canny, profundidad y relleno inteligente mediante parches de modelo.

![Vista previa del flujo de trabajo del parche de modelo ControlNet de Qwen-Image](https://raw.githubusercontent.com/Comfy-Org/workflow_templates/main/templates/image_qwen_image_controlnet_patch-1.webp)

> **[Ejecutar en Comfy Cloud](https://cloud.comfy.org/?template=image_qwen_image_controlnet_patch\&utm_source=docs\&utm_medium=referral\&utm_campaign=qwen-image)**
>
> Abrir en Comfy Cloud

> **[Descargar flujo de trabajo](https://github.com/Comfy-Org/workflow_templates/blob/main/templates/image_qwen_image_controlnet_patch.json)**
>
> Descarga el JSON o busca "Qwen-Image ControlNet Patch" en la Biblioteca de plantillas

**Materiales de entrada**

Sube este archivo al nodo `LoadImage` correspondiente:

> **[image\_qwen\_image\_controlnet\_patch\_input\_image.png](https://raw.githubusercontent.com/Comfy-Org/workflow_templates/main/input/image_qwen_image_controlnet_patch_input_image.png)**
>
> Nodo `LoadImage` 71 · `image_qwen_image_controlnet_patch_input_image.png`

![image\_qwen\_image\_controlnet\_patch\_input\_image.png](https://raw.githubusercontent.com/Comfy-Org/workflow_templates/main/input/image_qwen_image_controlnet_patch_input_image.png)

### 1. Flujo de trabajo e imágenes de entrada

Después de actualizar ComfyUI, puedes encontrar el archivo del flujo de trabajo en las plantillas, o arrastrar la vista previa del flujo de trabajo que aparece arriba hacia ComfyUI para cargarlo.

### 2. Enlaces a los modelos

Los demás modelos son los mismos que en el flujo de trabajo básico de Qwen-Image. Solo necesitas descargar los modelos siguientes y guardarlos en la carpeta `ComfyUI/models/model_patches`

* [qwen\_image\_canny\_diffsynth\_controlnet.safetensors](https://huggingface.co/Comfy-Org/Qwen-Image-DiffSynth-ControlNets/blob/main/split_files/model_patches/qwen_image_canny_diffsynth_controlnet.safetensors)
* [qwen\_image\_depth\_diffsynth\_controlnet.safetensors](https://huggingface.co/Comfy-Org/Qwen-Image-DiffSynth-ControlNets/blob/main/split_files/model_patches/qwen_image_depth_diffsynth_controlnet.safetensors)
* [qwen\_image\_inpaint\_diffsynth\_controlnet.safetensors](https://huggingface.co/Comfy-Org/Qwen-Image-DiffSynth-ControlNets/blob/main/split_files/model_patches/qwen_image_inpaint_diffsynth_controlnet.safetensors)

### 3. Instrucciones de uso del flujo de trabajo

Actualmente, diffsynth tiene tres modelos de parche: Canny, Profundidad y Relleno inteligente.

Si es la primera vez que usas flujos de trabajo relacionados con ControlNet, debes saber que las imágenes de control deben preprocesarse a formatos de imagen compatibles antes de que el modelo pueda usarlas y reconocerlas.

![Diagrama de tipos de entrada](https://mintcdn.com/dripart/SIDaLac8vBogzwm7/images/tutorial/image/qwen/controlnet_input_types.jpg?fit=max\&auto=format\&n=SIDaLac8vBogzwm7\&q=85\&s=3459806aaf59d27e2e1554c4bd2d0de7)

* Canny: borde Canny procesado, contornos de line art
* Profundidad: mapa de profundidad preprocesado que muestra las relaciones espaciales
* Relleno inteligente: requiere usar una máscara para marcar las áreas que se deben repintar

Como este modelo de parche se divide en tres modelos diferentes, debes seleccionar el tipo de preprocesamiento correcto al introducir la imagen para garantizar un preprocesamiento adecuado de la misma.

**Instrucciones de uso de ControlNet con el modelo Canny**

![Flujo de trabajo con Canny](https://mintcdn.com/dripart/SIDaLac8vBogzwm7/images/tutorial/image/qwen/image_qwen_image_controlnet_patch-canny.jpg?fit=max\&auto=format\&n=SIDaLac8vBogzwm7\&q=85\&s=ca49f6ba72d3897cb14614314bc0d3c8)

1. Asegúrate de que `qwen_image_canny_diffsynth_controlnet.safetensors` esté cargado
2. Sube la imagen de entrada para el procesamiento posterior
3. El nodo Canny es un nodo de preprocesamiento nativo que preprocesa la imagen de entrada según los parámetros que definas para controlar la generación
4. Si lo necesitas, puedes modificar `strength` en el nodo `QwenImageDiffsynthControlnet` para controlar la intensidad del control de line art
5. Haz clic en el botón `Run` o usa el atajo `Ctrl(cmd) + Enter` para ejecutar el flujo de trabajo

> Para usar qwen\_image\_depth\_diffsynth\_controlnet.safetensors, debes preprocesar la imagen a un mapa de profundidad y reemplazar la parte de `image processing`. Para este uso, consulta el método de procesamiento de InstantX en este documento. Las demás partes son similares al uso del modelo Canny.

**Instrucciones de uso de ControlNet con el modelo de relleno inteligente**

![Flujo de trabajo de relleno inteligente](https://mintcdn.com/dripart/SIDaLac8vBogzwm7/images/tutorial/image/qwen/image_qwen_image_controlnet_patch-inpaint.jpg?fit=max\&auto=format\&n=SIDaLac8vBogzwm7\&q=85\&s=c3a3493ab00a11eba1e634624b40a2c1)

El modelo de relleno inteligente requiere usar el [Editor de máscara](https://docs.comfy.org/es/interface/maskeditor.md) para dibujar una máscara y usarla como condición de control de entrada.

1. Asegúrate de que `ModelPatchLoader` cargue el modelo `qwen_image_inpaint_diffsynth_controlnet.safetensors`
2. Sube la imagen y usa el [Editor de máscara](https://docs.comfy.org/es/interface/maskeditor.md) para dibujar una máscara. Debes conectar la salida `mask` del nodo `Load Image` correspondiente a la entrada `mask` de `QwenImageDiffsynthControlnet` para asegurar que se cargue la máscara correspondiente
3. Usa el atajo `Ctrl-B` para poner el Canny original del flujo de trabajo en modo Omitir, de modo que el procesamiento del nodo Canny correspondiente no tenga efecto
4. En `CLIP Text Encoder`, escribe aquello a lo que quieres cambiar el área enmascarada
5. Si lo necesitas, puedes modificar `strength` en el nodo `QwenImageDiffsynthControlnet` para controlar la intensidad de control correspondiente
6. Haz clic en el botón `Run` o usa el atajo `Ctrl(cmd) + Enter` para ejecutar el flujo de trabajo

## Flujo de trabajo LoRA de ControlNet Union de Qwen Image

### Control Union de Qwen-Image

Genera imágenes con un control estructural preciso usando el LoRA de ControlNet unificado de Qwen-Image. Es compatible con varios tipos de control, como canny, profundidad, arte lineal, softedge, normal y openpose.

![Vista previa del flujo de trabajo Control Union de Qwen-Image](https://raw.githubusercontent.com/Comfy-Org/workflow_templates/main/templates/image_qwen_image_union_control_lora-1.webp)

> **[Ejecutar en Comfy Cloud](https://cloud.comfy.org/?template=image_qwen_image_union_control_lora\&utm_source=docs\&utm_medium=referral\&utm_campaign=qwen-image)**
>
> Abrir en Comfy Cloud

> **[Descargar flujo de trabajo](https://github.com/Comfy-Org/workflow_templates/blob/main/templates/image_qwen_image_union_control_lora.json)**
>
> Descarga el JSON o busca "Qwen-Image Union Control" en la Biblioteca de plantillas

**Materiales de entrada**

Sube este archivo al nodo `LoadImage` correspondiente:

> **[image\_qwen\_image\_union\_control\_lora\_input\_image.png](https://raw.githubusercontent.com/Comfy-Org/workflow_templates/main/input/image_qwen_image_union_control_lora_input_image.png)**
>
> nodo `LoadImage` 73 · `image_qwen_image_union_control_lora_input_image.png`

![image\_qwen\_image\_union\_control\_lora\_input\_image.png](https://raw.githubusercontent.com/Comfy-Org/workflow_templates/main/input/image_qwen_image_union_control_lora_input_image.png)

**Salida de ejemplo**

![Imagen de entrada](https://raw.githubusercontent.com/Comfy-Org/workflow_templates/main/input/image_qwen_image_union_control_lora_input_image.png)

![Salida de ejemplo del Control Union de Qwen-Image](https://raw.githubusercontent.com/Comfy-Org/workflow_templates/main/output/image_qwen_image_union_control_lora.png)

Dirección del modelo original: [DiffSynth-Studio/Qwen-Image-In-Context-Control-Union](https://www.modelscope.cn/models/DiffSynth-Studio/Qwen-Image-In-Context-Control-Union/)
Dirección de rehospedaje de Comfy Org: [qwen\_image\_union\_diffsynth\_lora.safetensors](https://huggingface.co/Comfy-Org/Qwen-Image-DiffSynth-ControlNets/blob/main/split_files/loras/qwen_image_union_diffsynth_lora.safetensors): LoRA de control de estructura de imagen compatible con canny, profundidad, pose, arte lineal, softedge, normal y openpose

### 1. Flujo de trabajo e imágenes de entrada

Después de actualizar ComfyUI, puedes encontrar el archivo del flujo de trabajo en las plantillas, o arrastrar la vista previa del flujo de trabajo de arriba a ComfyUI para cargarlo.

### 2. Enlaces de modelos

Descarga el modelo que aparece a continuación. Como se trata de un modelo LoRA, debe guardarse en la carpeta `ComfyUI/models/loras/`

* [qwen\_image\_union\_diffsynth\_lora.safetensors](https://huggingface.co/Comfy-Org/Qwen-Image-DiffSynth-ControlNets/blob/main/split_files/loras/qwen_image_union_diffsynth_lora.safetensors): LoRA de control de estructura de imagen compatible con canny, profundidad, pose, arte lineal, softedge, normal y openpose

### 3. Instrucciones del flujo de trabajo

Este modelo es un LoRA de control unificado compatible con los controles canny, profundidad, pose, arte lineal, softedge, normal y openpose. Como muchos de los nodos nativos de preprocesamiento de imágenes no son totalmente compatibles, conviene usar algo como [comfyui\_controlnet\_aux](https://github.com/Fannovel16/comfyui_controlnet_aux) para completar el resto del preprocesamiento de imágenes.

![Union Control LoRA](https://mintcdn.com/dripart/SIDaLac8vBogzwm7/images/tutorial/image/qwen/image_qwen_image_union_control_lora.jpg?fit=max\&auto=format\&n=SIDaLac8vBogzwm7\&q=85\&s=428cafa03e7759a771c9f1e63d759dd0)

1. Asegúrate de que `LoraLoaderModelOnly` cargue correctamente el modelo `qwen_image_union_diffsynth_lora.safetensors`
2. Sube la imagen de entrada
3. Si es necesario, puedes ajustar los parámetros del nodo `Canny`. Como cada imagen de entrada requiere distintos valores de parámetros para obtener un mejor resultado de preprocesamiento, puedes probar a ajustar los valores correspondientes para obtener más o menos detalles
4. Haz clic en el botón `Run` o usa el atajo `Ctrl(cmd) + Enter` para ejecutar el flujo de trabajo

> Para otros tipos de control, también debes reemplazar la parte de procesamiento de imágenes.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.