Tienes una imagen generada con txt2img que tiene buena composición pero el estilo no es exactamente lo que querías. O tienes un boceto hecho a mano y quieres convertirlo en una ilustración renderizada. Img2img resuelve eso: en lugar de partir de ruido aleatorio, el KSampler parte de tu imagen, la modifica según el prompt y un parámetro llamado denoise, y devuelve algo nuevo que conserva la estructura original.
Este artículo asume que ya tienes ComfyUI funcionando. Si no, la guía de generación de imágenes con ComfyUI es el punto de partida. Los nodos que usamos aquí (VAEEncode, KSampler) están explicados en detalle en los nodos esenciales de ComfyUI.
🏗️ Workflow: IMG2IMG Pro
🏗️ Qué es img2img y cuándo usarlo
Txt2img genera imágenes desde cero: el KSampler empieza con ruido gaussiano puro y lo refina paso a paso guiado por el prompt. El resultado depende completamente del texto y la semilla aleatoria.
Img2img cambia el punto de partida. En lugar de ruido puro, el KSampler recibe un latente derivado de tu imagen de entrada. El proceso de denoising modifica ese latente de forma que el resultado se parezca a lo que describe el prompt, pero manteniendo la estructura compositiva de la imagen original.
Cuándo usar img2img sobre txt2img:
- Tienes una composición buena pero el estilo está mal — cambias estilo sin perder la disposición de elementos
- Quieres iterar sobre un resultado existente — refinas detalles de una imagen que ya te gusta en general
- Tienes un boceto o referencia visual — conviertes dibujos, wireframes o fotos en ilustraciones renderizadas
- Necesitas consistencia entre variaciones — mantienes la misma escena con ligeras diferencias
Cuando el resultado de txt2img ya es bueno y solo quieres pequeños ajustes, img2img con denoise bajo (0.2-0.4) es mucho más eficiente que regenerar desde cero.
🏗️ El parámetro denoise: la clave de img2img
Denoise es el único parámetro que diferencia img2img de txt2img. Controla qué fracción del proceso de denoising se aplica partiendo de la imagen de entrada.
Con denoise=1.0, el KSampler añade el máximo de ruido posible a la imagen antes de empezar a refinarla — el resultado es equivalente a txt2img. Con denoise=0.0, no se añade ruido y la imagen no cambia en absoluto.
| Valor denoise | Qué hace | Cuándo usarlo |
|---|---|---|
| 0.0 | Sin cambios. Imagen idéntica a la entrada | Solo para probar el workflow |
| 0.1 – 0.3 | Cambios mínimos. Ajustes de textura y color muy sutiles | Correcciones muy finas de calidad |
| 0.3 – 0.5 | Cambios de estilo moderados. La composición se mantiene intacta | Cambio de estilo artístico, ajustar iluminación |
| 0.5 – 0.7 | Transformación notable. La estructura principal se conserva pero cambian muchos detalles | Rediseño de personajes, cambio de entorno |
| 0.7 – 0.9 | Cambios grandes. La imagen original solo influye en la disposición general | Transformaciones radicales de estilo |
| 1.0 | Equivalente a txt2img. La imagen de entrada no influye en el resultado | No tiene sentido usarlo en img2img |
El rango más útil en la práctica es 0.4 – 0.7. Por debajo de 0.4 los cambios son demasiado tímidos a menos que uses un prompt muy específico. Por encima de 0.7 puedes perder la composición que querías preservar.
🏗️ Los nodos del workflow img2img
El workflow img2img añade dos nodos sobre el workflow básico de txt2img: LoadImage y VAEEncode. El resto es idéntico.
🏗️ LoadImage
Carga la imagen de entrada desde disco. Soporta PNG, JPG y WEBP. Tiene un botón “Upload” para seleccionar el archivo desde tu sistema de archivos.
Salidas: imagen (IMAGE) y máscara (MASK). Para img2img solo necesitas la salida IMAGE.
🏗️ VAEEncode
Convierte la imagen del espacio de píxeles al espacio latente. El KSampler no trabaja con píxeles directamente — trabaja con representaciones latentes de mucho menor resolución que el VAE (Variational Autoencoder) comprime y descomprime. VAEEncode hace esa compresión: toma la imagen real y devuelve su equivalente latente.
Entradas:
pixels— la imagen que sale de LoadImagevae— el VAE que sale del CheckpointLoaderSimple
Salida: LATENT — el latente que va al KSampler como latent_image.
Sin VAEEncode no puedes pasar una imagen al KSampler. Ese nodo es la pieza central que hace posible img2img.
🏗️ KSampler con denoise < 1.0
El KSampler en img2img es exactamente el mismo que en txt2img, con una diferencia: el parámetro denoise debe estar por debajo de 1.0. Si lo pones en 1.0, ignora completamente la imagen de entrada.
El campo latent_image recibe el latente de VAEEncode en lugar del EmptyLatentImage que usarías en txt2img.
🏗️ VAEDecode y SaveImage
Idénticos al workflow básico. VAEDecode convierte el latente resultante de vuelta a píxeles, y SaveImage guarda el archivo en la carpeta output/ de ComfyUI.
🏗️ Construir el workflow paso a paso
Empieza desde el workflow de txt2img por defecto que carga ComfyUI al arrancar. La estructura base (CheckpointLoaderSimple → CLIPTextEncode × 2 → KSampler → VAEDecode → SaveImage) se mantiene. Solo hay que añadir dos nodos y reconectar latent_image.
Paso 1: Añadir LoadImage
Haz clic derecho en el canvas → Add Node → Image → Load Image. Aparece el nodo LoadImage. Sube tu imagen con el botón Upload.
Paso 2: Añadir VAEEncode
Haz clic derecho en el canvas → Add Node → Latent → VAE Encode. Aparece el nodo VAEEncode.
Paso 3: Conectar LoadImage → VAEEncode
Arrastra desde la salida IMAGE de LoadImage hasta la entrada pixels de VAEEncode.
Paso 4: Conectar el VAE a VAEEncode
El CheckpointLoaderSimple tiene tres salidas: MODEL, CLIP y VAE. La salida VAE ya va conectada a VAEDecode — añade una segunda conexión desde esa misma salida VAE hasta la entrada vae de VAEEncode. En ComfyUI puedes conectar una salida a múltiples entradas.
Paso 5: Conectar VAEEncode → KSampler
Arrastra desde la salida LATENT de VAEEncode hasta la entrada latent_image del KSampler. Si el KSampler tenía un EmptyLatentImage conectado, desconéctalo — ya no lo necesitas.
Paso 6: Ajustar denoise en el KSampler
Cambia el campo denoise del KSampler de 1.0 a tu valor objetivo. Empieza con 0.5 para la primera prueba.
Paso 7: Queue Prompt
El workflow está listo. Escribe tu prompt, haz clic en “Queue Prompt” y espera 15-30 segundos (con SDXL en una RTX 3060 o similar).
El workflow completo tiene esta forma:
CheckpointLoaderSimple
├─ MODEL ──────────────────────────────→ KSampler.model
├─ CLIP ──────────────────────────────→ CLIPTextEncode (×2) → KSampler
└─ VAE ──────────────────────────────→ VAEEncode.vae
└→ VAEDecode.vae
LoadImage → IMAGE → VAEEncode.pixels
VAEEncode → LATENT → KSampler.latent_image
KSampler → LATENT → VAEDecode → IMAGE → SaveImage🏗️ Casos de uso prácticos
🏗️ Cambiar el estilo artístico de una foto
Tienes una fotografía y quieres convertirla en una ilustración estilo anime, pintura al óleo o comic book.
Configuración recomendada:
- Denoise: 0.55 – 0.65
- Prompt: describe el estilo objetivo con detalle (“anime style, cel shading, vibrant colors, detailed linework”)
- Negative prompt: “photorealistic, photograph, realistic”
- Steps: 30-40 (más steps ayudan con transformaciones grandes)
Con denoise de 0.6 y un prompt de estilo claro, la composición se mantiene pero la estética cambia de forma reconocible.
🏗️ Mejorar la calidad de un boceto
Tienes un dibujo hecho a mano o un boceto digital y quieres añadir detalles, sombras y textura.
Configuración recomendada:
- Denoise: 0.4 – 0.55
- Prompt: describe el resultado final con detalles (“detailed illustration, professional shading, clean linework, high quality”)
- La imagen de entrada es el boceto escaneado o fotografiado
🏗️ Iterar sobre un resultado de txt2img
Generaste una imagen con txt2img que tiene buena composición pero algunos detalles están mal (una mano, un fondo, una textura). En lugar de regenerar desde cero, usa img2img con denoise bajo.
Configuración recomendada:
- Denoise: 0.2 – 0.4
- Mismo prompt que usaste para generar la imagen original
- El resultado corrige detalles manteniendo lo que ya funcionaba
Este flujo de trabajo — txt2img para la composición, img2img para refinar — es uno de los más comunes en producción.
🏗️ Img2img con LoRA
Combinar img2img con LoRAs no requiere ningún cambio en la estructura principal del workflow. El nodo LoraLoader se inserta entre CheckpointLoaderSimple y los nodos que consumen MODEL y CLIP.
Añade el nodo LoraLoader (clic derecho → Add Node → Loaders → Load LoRA) y conecta:
CheckpointLoaderSimple.MODEL → LoraLoader.model
CheckpointLoaderSimple.CLIP → LoraLoader.clip
LoraLoader.MODEL → KSampler.model
LoraLoader.CLIP → CLIPTextEncode (×2)El resto del workflow (LoadImage → VAEEncode → KSampler) no cambia. La LoRA influye en el estilo de la transformación exactamente igual que en txt2img: si usas una LoRA de estilo acuarela con denoise 0.6, el resultado combinará la composición de tu imagen con la estética de la LoRA.
Parámetro strength_model y strength_clip en LoraLoader controlan cuánto influye la LoRA. Valores entre 0.6 y 0.9 son habituales para img2img — si la LoRA es demasiado agresiva, baja estos valores antes de tocar el denoise.
Para una guía completa sobre LoRAs, consulta cómo usar LoRAs en ComfyUI.
🏗️ Upscale después de img2img
Un flujo habitual es usar img2img en resolución baja (512×512 o 768×768) para iterar rápido y luego hacer upscale del resultado. Esto reduce el tiempo de cada prueba a 5-10 segundos y el upscale se hace una sola vez al final.
La forma más simple de añadir upscale al workflow:
- Añade un nodo UpscaleModelLoader y carga un modelo de upscale (RealESRGAN_x4plus, 4x-UltraSharp, etc.)
- Añade un nodo ImageUpscaleWithModel
- Conecta la salida
IMAGEde VAEDecode a la entradaimagede ImageUpscaleWithModel - Conecta UpscaleModelLoader a
upscale_model - Conecta la salida de ImageUpscaleWithModel a SaveImage
El resultado del img2img se upscalea ×4 antes de guardar. Con RealESRGAN_x4plus en una GPU de 6GB, el upscale de una imagen 512×512 a 2048×2048 tarda 2-4 segundos adicionales.
🏗️ Resolución de imagen y resize en VAEEncode
VAEEncode espera que las dimensiones de la imagen sean múltiplos de 64. Si tu imagen tiene dimensiones irregulares (por ejemplo, una foto de 1920×1080 recortada a 847×623), el workflow puede fallar o producir artefactos.
ComfyUI incluye el nodo ImageScale para redimensionar antes de codificar. Añádelo entre LoadImage y VAEEncode:
- Conecta
IMAGEde LoadImage →imagede ImageScale - Conecta la salida de ImageScale →
pixelsde VAEEncode - Configura ImageScale con
widthyheighten múltiplos de 64 (512, 768, 1024) - Método de interpolación:
lanczospara fotos,nearest-exactpara píxel art
Para SDXL, las resoluciones nativas son 1024×1024 o combinaciones como 1152×896, 896×1152. Usar estas resoluciones con SDXL da mejores resultados que resoluciones arbitrarias.
🏗️ Solución de problemas
🏗️ La imagen resultado es demasiado diferente a la original
El denoise es demasiado alto. Bájalo 0.1-0.15 y prueba de nuevo. Si con denoise 0.5 la composición se pierde demasiado, intenta con 0.35.
También puede ser que el prompt sea demasiado diferente a la imagen de entrada — si la imagen es un retrato y el prompt describe un paisaje, incluso con denoise bajo el resultado puede ser caótico.
🏗️ La imagen resultado es casi idéntica a la original
El denoise es demasiado bajo. Súbelo 0.15-0.2 por encima de donde estás. Con denoise menor a 0.2 los cambios son tan sutiles que apenas se notan.
Otra causa: el prompt no es suficientemente específico o descriptivo. Añade más detalles estilísticos.
🏗️ Artefactos o ruido en áreas específicas
Suele pasar cuando la imagen de entrada tiene compresión JPEG agresiva. Usa PNG para las imágenes de entrada siempre que puedas. Si la fuente es JPEG, sube ligeramente el denoise (0.05-0.1) para que el denoising corrija los artefactos de compresión.
🏗️ CUDA out of memory con SDXL
El consumo de VRAM en img2img con SDXL es similar al de txt2img: 6GB es el mínimo. Si falla con 6GB:
- Usa
--lowvramal arrancar ComfyUI (python main.py --lowvram) - Reduce la resolución a 768×768 en lugar de 1024×1024
- Cambia a SD 1.5 que consume significativamente menos VRAM
🏗️ El workflow no encuentra la imagen
LoadImage carga desde la carpeta input/ de ComfyUI por defecto. Si subes la imagen con el botón Upload, se copia ahí automáticamente. Si intentas referenciar una ruta absoluta del sistema, usa el nodo Load Image (from path) disponible en algunos packs de nodos personalizados.
🏗️ Comparación de velocidad: img2img vs txt2img
Con una RTX 3060 (12GB VRAM) y SDXL Base 1.0 a 1024×1024, 30 steps:
| Modo | Denoise | Tiempo por imagen |
|---|---|---|
| Txt2img | 1.0 | ~22 segundos |
| Img2img | 0.7 | ~16 segundos |
| Img2img | 0.5 | ~12 segundos |
| Img2img | 0.3 | ~8 segundos |
El tiempo se reduce aproximadamente proporcional al denoise porque el KSampler ejecuta menos steps efectivos. Con denoise=0.5 y 30 steps configurados, el KSampler hace efectivamente ~15 steps de denoising.
Esto hace que img2img con denoise bajo sea una forma muy eficiente de iterar: pruebas en 8-12 segundos son mucho más ágiles que esperar 22 segundos por cada variación.
Img2img es la técnica que separa iterar con control de regenerar a ciegas. Con el workflow de cinco nodos que has construido aquí y el denoise ajustado a tu caso de uso, puedes transformar cualquier imagen de entrada con precisión quirúrgica. El siguiente paso natural es añadir ControlNet para tener aún más control sobre qué partes de la composición se preservan — o combinar lo aprendido aquí con LoRAs siguiendo la guía de LoRAs en ComfyUI. Si quieres entender mejor qué hace cada nodo que has conectado, los nodos esenciales de ComfyUI explica VAEEncode, KSampler y el resto con más profundidad.
Preguntas frecuentes
- ¿Qué hace el parámetro denoise en img2img de ComfyUI?
- Denoise controla cuánto se aleja el resultado de la imagen original. Con 0.0 la imagen no cambia nada. Con 1.0 el KSampler ignora completamente la imagen de entrada y actúa como txt2img. Los valores prácticos van de 0.3 a 0.7: suficiente para cambiar estilo o añadir detalles sin perder la composición.
- ¿Cuánta VRAM necesito para img2img en ComfyUI con SDXL?
- El consumo de VRAM en img2img con SDXL es prácticamente igual al de txt2img: 6GB es el mínimo funcional. Con 8GB trabajas con más margen. Si tienes menos de 6GB, usa SD 1.5 (2GB de modelo) con resoluciones de 512×512 — img2img funciona igual con modelos más ligeros.
- ¿Cuál es la diferencia entre img2img y txt2img en ComfyUI?
- En txt2img el KSampler parte de ruido puro (denoise=1.0). En img2img partes de una imagen real que VAEEncode convierte al espacio latente, y el KSampler usa ese latente como punto de partida con un denoise menor a 1.0. El resultado mantiene la estructura de la imagen original según lo bajo que pongas el denoise.
- ¿Puedo combinar img2img con LoRAs en ComfyUI?
- Sí. El nodo LoraLoader se conecta entre CheckpointLoaderSimple y los encoders de texto (CLIPTextEncode) y modelo (KSampler). El workflow img2img es idéntico salvo por ese nodo adicional. La LoRA afecta el estilo de la transformación igual que en txt2img.
