¿Qué es Qwen-Image-2.1?
Qwen Image 2.1 es un modelo unificado de generación y edición de imágenes.
Su componente de generación visual contiene 7.000 millones de parámetros. El modelo admite generación de texto a imagen, transparencia nativa, múltiples imágenes de referencia y edición local guiada por anotaciones o máscaras. Este tutorial se centra en la edición RGB con una única referencia.
El modelo ya ofrece la capacidad de edición. Nuestra aplicación añade el flujo que la rodea: selección de entrada, revisión de candidatos, gestión de fotogramas aceptados y su exportación. No entrenamos un modelo nuevo ni añadimos un módulo de movimiento.
El GIF resultante reproduce imágenes fijas generadas de forma independiente. Puede mostrar cambios de pose y variaciones visuales, pero no equivale a una generación de vídeo con consistencia temporal.
¿Cómo funciona Qwen Image 2.1?
La arquitectura oficial identifica cuatro componentes principales:
|
Componente |
Especificación |
Papel |
|
Transformador visual |
Transformador de difusión (DiT) monoflujo de 32 capas y 7B parámetros |
Procesa los tokens de condicionamiento y de la imagen objetivo en un flujo compartido |
|
Codificador de texto e imagen |
Qwen3-VL 8B |
Codifica instrucciones e imágenes de referencia en una representación unificada |
|
Autoencoder de imagen (VAE) |
64 canales latentes, soporte RGBA, compresión espacial 16× |
Convierte imágenes a latentes compactos y decodifica latentes generados a píxeles |
|
Proceso de generación |
Flow matching con planificación Euler discreta y desplazamiento dinámico |
Actualiza iterativamente los latentes de la imagen objetivo hacia la imagen generada |
El transformador visual contiene 7.000 millones de parámetros. Este recuento excluye el codificador de texto e imagen y el VAE.
Los 64 canales del VAE hacen referencia a su representación latente, no a 64 canales de color de salida.
La salida RGBA contiene canales rojo, verde, azul y alfa. La app aplana las cargas a RGB, así que no demuestra la compatibilidad con transparencia nativa del modelo.
Cómo leer el diagrama de atención
Qwen Image 2.1 usa una máscara de atención de granularidad mixta: las celdas coloreadas permiten atención y las grises la bloquean.

Figura 1: arquitectura de atención de granularidad mixta de Qwen Image 2.1 (entrada del blog de Qwen)
Lee el diagrama por filas: Q representa los tokens de consulta y K los tokens a los que pueden atender. La secuencia contiene un prefijo del sistema, una imagen de entrada opcional, una instrucción de edición y la imagen objetivo.
El texto usa atención causal porque un token de texto puede atenderse a sí mismo y a posiciones anteriores. Los tokens dentro del mismo bloque de imagen pueden atenderse en ambas direcciones.
Esto produce las regiones triangulares de texto y los bloques sólidos de imagen que se muestran en la figura 1.
La regla de la máscara expresa esa combinación así:
allowed = (q_idx >= kv_idx) or same_image_block
Es una regla conceptual para un par de posiciones de tokens, no un ajuste adicional que pegar en el notebook. Permite la atención a posiciones anteriores y autoriza atención todos-contra-todos dentro de cada bloque de imagen.
¿Por qué se puede cachear un prefijo?
El prefijo del sistema, la imagen de referencia y la instrucción no pueden atender al bloque posterior de la imagen objetivo.
Por tanto, sus representaciones no necesitan cambiar a medida que se actualiza la imagen objetivo.
Qwen calcula sus claves y valores de atención una vez en el primer paso de denoise y los reutiliza en los pasos siguientes. Los tokens de la imagen objetivo sí requieren cómputo en cada paso, atendiendo al prefijo en caché y entre sí.
Con 40 pasos, el prefijo fijo puede reutilizarse tras el primero; esto no implica una aceleración de 40× porque queda mucho cómputo en la imagen objetivo.
Esta reutilización de caché sucede entre pasos de denoise dentro de una misma generación. No significa que el modelo recuerde peticiones anteriores del usuario ni que nuestra app reutilice automáticamente la misma caché entre ediciones enviadas por separado.
Demo: crea un editor de imágenes con Qwen Image 2.1
Antes de construir la app, separemos la configuración del modelo de las decisiones de la aplicación. Ten en cuenta que aumentar el número de pasos no arreglará una canalización que sigue devolviendo imágenes dañadas al modelo.
|
Ajuste |
Valor usado |
Por qué importa |
|
Imagen de referencia |
Imagen original para cada edición en la app final |
Evita arrastrar artefactos de un fotograma generado al siguiente |
|
Resolución |
1024 |
Objetivo de edición de aproximadamente un megapíxel en este backend |
|
Pasos de inferencia |
40 |
Presupuesto de muestreo usado en los experimentos principales |
|
Seed |
42 |
Mantiene fija la semilla de muestreo mientras pruebas instrucciones |
|
CFG |
1,0 |
Coincide con el flujo suministrado; la guía negativa estándar no aporta a este valor |
|
Sampler/scheduler |
Euler / simple |
Mantiene sin cambios la configuración de muestreo proporcionada |
|
Denoise |
1,0 |
Se ajusta a este flujo de edición por instrucciones; no es una receta img2img de bajo denoise convencional |
|
Decodificación VAE |
Sin teselar en la configuración final |
Elegida tras una mejora cualitativa durante el desarrollo |
|
Pesos |
Modelo de imagen y codificador de texto INT8 ConvRot; VAE BF16 |
Backend ajustado a memoria usado para la demo |
|
Descarga a CPU del encoder/cache de referencia |
Desactivado al inicio |
La sesión en A100 encajó sin activar estos ajustes adicionales de descarga |
Son ajustes operativos para este proyecto, no una configuración óptima universal. No realizamos una exploración sistemática de pasos, CFG, samplers o formatos de cuantización.
Los valores del sampler provienen del flujo de trabajo de edición de imagen, que me permitió ejecutar este modelo con poca VRAM.
Paso 1: prepara el entorno en Colab
La ejecución grabada usó una NVIDIA A100-SXM4-40GB, con 83,5 GiB de RAM del host.
Utilicé el paquete de instalación alesha-pro para instalar ComfyUI y descargar los pesos cuantizados.
Ten en cuenta que necesitas planificar alrededor de 45 GB de almacenamiento libre, incluyendo entorno, modelos, cachés y salidas.
Un runtime con mucha RAM da margen durante las cargas y descargas.
Primero, define las rutas y comprueba la GPU:
import sys, os, json, time, uuid, shutil, subprocess, copy, io, threading
from pathlib import Path
from PIL import Image, ImageDraw, ImageFilter, ImageOps
import numpy as np
import requests
import gradio as gr
from IPython.display import display, Image as DisplayImage
ROOT = Path('/content/qwen_gif_demo')
ROOT.mkdir(parents=True, exist_ok=True)
TOOLS = ROOT / 'tools'
COMFY = ROOT / 'ComfyUI'
RUNS = ROOT / 'runs'
RUNS.mkdir(exist_ok=True)
REPO_REV = 'dc0083c0d17581f04ebbca962771e36f82f31af8'
BASE = 'http://127.0.0.1:8188'
def run_cmd(args, **kwargs):
print('Running:', ' '.join(map(str, args)), flush=True)
subprocess.run(list(map(str, args)), check=True, **kwargs)
if not shutil.which('nvidia-smi'):
raise RuntimeError('Select a GPU runtime before continuing.')
print(subprocess.check_output(['nvidia-smi'], text=True))
La comprobación de la GPU detiene la ejecución si Colab sigue usando CPU, y también imprimimos detalles sobre la RAM del host y el espacio libre en disco antes de la instalación.
Las importaciones son básicas e incluyen librerías estándar de Python para gestionar rutas de archivos, flujos de trabajo en JSON, procesos de backend, temporización y monitorización en segundo plano.
Pillow y NumPy gestionan el procesado de imágenes, Requests se comunica con ComfyUI, Gradio proporciona la interfaz e IPython muestra imágenes en el notebook.
Instala el backend por separado de la UI
ComfyUI se ejecuta en su propio entorno virtual. El kernel del notebook gestiona subidas, peticiones HTTP y Gradio.
if not TOOLS.exists():
run_cmd(['git', 'init', TOOLS])
run_cmd(['git', '-C', TOOLS, 'remote', 'add', 'origin', 'https://github.com/alesha-pro/tools.git'])
run_cmd(['git', '-C', TOOLS, 'fetch', '--depth', '1', 'origin', REPO_REV])
run_cmd(['git', '-C', TOOLS, 'checkout', '--detach', 'FETCH_HEAD'])
assert subprocess.check_output(['git', '-C', str(TOOLS), 'rev-parse', 'HEAD'], text=True).strip() == REPO_REV
PKG = TOOLS / 'qwen-image-2.1'
VERSIONS = json.loads((PKG / 'install/versions.json').read_text())
print('Pinned backend:', VERSIONS)
driver = subprocess.check_output(['nvidia-smi', '--query-gpu=driver_version', '--format=csv,noheader'], text=True).splitlines()[0]
# Conservative selector; the backend CUDA smoke test is authoritative.
TORCH_INDEX = 'https://download.pytorch.org/whl/cu130' if int(driver.split('.')[0]) >= 580 else 'https://download.pytorch.org/whl/cu128'
print('Driver:', driver, '| wheel index:', TORCH_INDEX)
run_cmd([sys.executable, PKG / 'install/setup.py', 'install', '--dir', COMFY, '--torch-index', TORCH_INDEX])
BACKEND_PY = COMFY / '.venv/bin/python'
run_cmd([BACKEND_PY, '-c', "import torch; print(torch.__version__, torch.version.cuda); print(torch.cuda.get_device_name(0)); x=torch.ones(16,device='cuda'); print(x.sum().item())"])
run_cmd([BACKEND_PY, PKG / 'install/download_models.py', '--models-dir', COMFY / 'models'])
Este código obtiene la fuente fijada, lee su configuración de versiones, instala el backend, prueba una operación CUDA con tensores y descarga los modelos.
La selección del wheel de CUDA usa la versión del driver como heurística inicial.
La prueba rápida CUDA es una verificación importante porque una A100 por sí sola no garantiza compatibilidad con cualquier build de PyTorch. Mi sesión usó el driver 580.82.07.
Paso 2: inicia el backend y define los parámetros de inferencia
La celda de arranque lanza ComfyUI en 127.0.0.1:8188, espera a que esté listo y recupera las definiciones de nodos disponibles.
El código se comunica con él mediante un pequeño helper HTTP:
def api(path, body=None):
r = requests.get(BASE + path, timeout=30) if body is None else requests.post(BASE + path, json=body, timeout=30)
if not r.ok:
raise RuntimeError(f'{path}: HTTP {r.status_code}: {r.text[:3000]}')
return r.json()
Este helper convierte fallos del servidor en excepciones legibles. Tras el arranque, el esquema de nodos está disponible con:
INFO = api('/object_info')
El código de inicio comprueba si ya existe un servidor antes de lanzar otro proceso. De este modo, no hay un túnel público de ComfyUI independiente en esta configuración.
Ahora define los parámetros que usaremos para la edición:
CPU_ENCODER = False
CPU_REFERENCE_CACHE = False
TILED_VAE = False
STEPS = 40
SIZE = 1024
SEED = 42
Así debes interpretar estos ajustes:
STEPS: más iteraciones de muestreo suelen costar más tiempo. Usamos 40.SIZE: en el grafo de edición, 1024 apunta a aproximadamente un megapíxel adaptando las dimensiones a la referencia. No fuerza salida cuadrada.SEED: una semilla fija facilita comparar dentro del mismo montaje. No garantiza preservación de identidad ni transiciones suaves entre prompts distintos.TILED_VAE: la decodificación sin teselar procesa la imagen sin el camino de teselas pequeñas configurado. Puede requerir más memoria. La preferimos por pruebas visuales, no por una demostración controlada de que el teselado causara todos los artefactos.- Flags de descarga a CPU: son controles de gestión de memoria, no de calidad de imagen. Actívalos solo cuando sea necesario y mide la latencia y la RAM resultantes.
De forma parecida, un prompt negativo no es el control principal que ajustar con CFG 1. Déjalo vacío en lugar de esperar que una lista larga de propiedades no deseadas arregle una edición floja.
Paso 3: conecta el prompt y la imagen de referencia al modelo
El generador del flujo de trabajo carga un grafo de API y sustituye sus entradas específicas de la petición. El siguiente fragmento muestra la ruta de edición:
g = json.loads((PKG / 'workflows/api/03-image-edit.json').read_text())
g['4']['inputs'].update(prompt=prompt, resolution=SIZE)
g['6']['inputs'].update(seed=int(seed), steps=int(STEPS))
g['9']['inputs']['image'] = upload_image(image_path)
if CPU_REFERENCE_CACHE:
g['11']['inputs']['device'] = 'cpu'
if CPU_ENCODER:
g['2']['inputs']['device'] = 'cpu'
Aquí, el nodo 4 recibe la instrucción de edición y la resolución.
El nodo 6 controla el muestreo y el nodo 9 carga la referencia subida.
Las otras dos anulaciones mueven opcionalmente trabajo del encoder o de la caché de referencia a la memoria del host.
El helper de inferencia envía entonces el grafo y espera su propio ID de petición:
response = api('/prompt', {
'prompt': g,
'client_id': uuid.uuid4().hex,
})
result = collect_result(response['prompt_id'], folder)
Aquí, folder es el directorio de salida por petición creado dentro de infer().
El recolector consulta el historial y descarga el PNG generado cuando termina el trabajo correspondiente.
También guardamos la entrada, el grafo, el envío, el historial y las métricas. Así puedes inspeccionar la petición real cuando una salida no tenga buena pinta.
Un timeout no cancela automáticamente el trabajo en GPU, así que conserva el ID de petición antes de decidir reintentar.
Paso 4: prepara una imagen original
La app final siempre necesita una referencia inalterada a la que volver. La siguiente ruta de subida aplica corrección de orientación, aplana la transparencia y añade la imagen a un lienzo cuadrado antes de pasársela al modelo:
python
from google.colab import files
uploaded = files.upload()
assert len(uploaded) == 1, 'Upload exactly one image.'
with Image.open(io.BytesIO(next(iter(uploaded.values())))) as image:
rgba = ImageOps.exif_transpose(image).convert('RGBA')
background = Image.new('RGBA', rgba.size, (250, 240, 230, 255))
original = Image.alpha_composite(background, rgba).convert('RGB')
original = ImageOps.pad(original, (SIZE, SIZE), color=(250, 240, 230))
BASE_FRAME = ROOT / f'original-{uuid.uuid4().hex[:8]}.png'
original.save(BASE_FRAME)
El relleno conserva la proporción en lugar de estirar el sujeto, pero puede introducir bordes.
Una subida directa en el editor de Gradio sigue su propio manejador y puede mantener las dimensiones originales. Por eso la app también comprueba las dimensiones de los candidatos antes de exportar.
Para editar poses, elige una imagen con espacio suficiente para el movimiento pedido y añade una instrucción acorde al límite.
Paso 5: guía las ediciones con texto y dibujos
Un dibujo es útil cuando el objetivo puede ser ambiguo, como elegir un brazo concreto o un objeto en una escena abarrotada.
En nuestra aplicación es totalmente opcional.
El editor de Gradio proporciona el fondo, las capas de dibujo y la imagen compuesta, y la regla importante de nuestro diseño final es cargar la original y añadir solo las capas de dibujo:
layers = editor_data.get('layers') or []
has_marks = any(
np.any(np.asarray(layer.convert('RGBA'))[..., 3] > 0)
for layer in layers if layer is not None
)
with Image.open(original_path) as image:
source = image.convert('RGBA').copy()
if has_marks:
for layer in layers:
if layer is None:
continue
layer = layer.convert('RGBA')
if layer.size != source.size:
raise ValueError('Clear the drawing and redraw on the original.')
source = Image.alpha_composite(source, layer)
Esta es la lógica central dentro del callback de edición.
El canal alfa revela si una capa contiene marcas visibles: un círculo, un rectángulo o un trazo aproximado, que pueden servir como guía visual.
Estas marcas no son una máscara de inpainting rígida. Indican al modelo dónde centrarse, pero no garantizan que el resto de píxeles permanezcan inalterados.
Podemos añadir la explicación de región solo cuando existan marcas:
region_instruction = (
'The red hand-drawn marks identify the target region. '
'For an outline, edit the enclosed area; for painted strokes, '
'edit the indicated area. Remove the annotation marks '
'from the final result. '
) if has_marks else ''
prompt = (
'Edit <image1>. '
+ region_instruction
+ f'Requested change: {instruction.strip()} '
+ "Preserve unrelated content and the image's framing. "
+ "Keep the subject's identity and visual style consistent "
+ 'unless the requested change explicitly alters them.'
)
La cláusula de preservación le indica al modelo qué es lo importante, pero sigue siendo una instrucción, no una garantía.
Para una prueba más explícita, especifica el lado relativo a la imagen y la pose final, por ejemplo:
instruction = (
'Lower the arm on the right side of the image so it extends '
'diagonally downward. Keep the other arm, face, body position, '
'camera framing, and background unchanged.'
)
Evita "muévelo un poco más" cuando cada petición parte de la original.
El modelo no recibe la conversación previa ni la última pose aceptada.
Paso 6: genera cada candidato desde la original
La primera versión de este proyecto generaba una secuencia alimentando cada salida en la siguiente petición:
result = edit_frame(manifest['frames'][-1], POSES[pose_index])

Es el comportamiento que cambié para la app final porque la edición repetida puede propagar artefactos: cada nueva petición parte de la salida anterior del modelo.
En nuestra secuencia inicial de la planta, las imágenes posteriores se volvieron notablemente más ruidosas.
La ruta final de generación usa la referencia original, opcionalmente anotada, en su lugar:
input_path = ROOT / f'edit-input-{uuid.uuid4().hex[:8]}.png'
source.convert('RGB').save(input_path)
result_path = infer(
'edit',
prompt,
seed=int(seed),
image_path=input_path,
)
Esto elimina el bucle de realimentación a través de imágenes previamente generadas.
No elimina los artefactos en salidas individuales ni fuerza que los fotogramas generados de forma independiente encajen a la perfección.
Si en una imagen aceptada hay una rosa, la siguiente petición no la hereda automáticamente. Para conservar la rosa mientras cambias la pose, hay que incluir ambos requisitos:
instruction = (
'Make the character hold a red rose in the hand on the right '
'side of the image, with that arm extended downward. '
'Preserve the other hand, face, background, and camera framing.'
)
Este compromiso es útil para generar variaciones desde una referencia común.
Para tareas que requieren ediciones acumulativas, un flujo secuencial puede seguir siendo apropiado, pero con expectativas diferentes sobre cambios acumulados.
Paso 7: revisa los candidatos antes de guardarlos
La app separa la original, la secuencia aceptada y el resultado pendiente usando la función State de Gradio:
original_state = gr.State(initial_path)
frames_state = gr.State(initial_frames)
pending_state = gr.State(None)
La secuencia empieza con la original y solo crece cuando el usuario acepta un candidato. El estado pendiente guarda un archivo generado que aún no se ha aceptado.
La operación central de aceptación es:
updated_frames = list(frames) + [pending_path]
Tras esta actualización, el callback completo limpia el candidato pendiente y el prompt, y devuelve el editor a la original.
Descartar limpia el resultado pendiente sin cambiar los fotogramas aceptados. Restablecer devuelve la secuencia a un único fotograma original y limpia la instrucción actual y la salida de descarga. Ninguna acción requiere recargar el modelo.
Paso 8: construye la app en Gradio
La interfaz final separa edición, fotogramas guardados y exportación en tres pestañas.

El componente clave es el editor de imágenes:
editor = gr.ImageEditor(
value=initial_editor,
type='pil',
image_mode='RGBA',
label='Input',
height=480,
brush=gr.Brush(
colors=['#ff0000'],
color_mode='fixed',
default_size=8,
),
eraser=gr.Eraser(default_size=20),
transforms=(),
)
El color fijo del pincel coincide con la instrucción de anotación.
La goma permite afinar regiones toscas, mientras que desactivar las transformaciones evita recortes y rotaciones en esta interacción.
El evento de generación pasa el estado original al callback:
event_options = {
'concurrency_id': 'edit_workflow',
'concurrency_limit': 1,
}
generate_button.click(
fn=generate_edit,
inputs=[editor, instruction, seed, original_state],
outputs=[candidate, pending_state, status],
**event_options,
)
Estos fragmentos de código van dentro del layout completo de Blocks.
El grupo de concurrencia compartido serializa la generación y los cambios de estado en esta demo. Restablecer espera su turno; no es un control de cancelación de trabajos en GPU.
Una vez definidos los handlers y componentes, lanza la app ejecutando:
demo.queue(default_concurrency_limit=1).launch(
share=True,
debug=True,
)
El enlace de compartición de Gradio expone el frontend, mientras que el backend permanece en localhost. Cambios de tema y CSS mejoran la presentación, pero no alteran la calidad de imagen.
Paso 9: convierte los fotogramas aceptados en un GIF
El exportador usa solo los fotogramas aceptados porque crea una paleta común y, opcionalmente, reproduce la secuencia al revés tras el fotograma final:
def export_gif(paths, destination, duration_ms=300, ping_pong=True):
frames = []
for path in paths:
with Image.open(path) as image:
frames.append(image.convert('RGB').copy())
if len(frames) < 2:
raise ValueError('Accept at least one edit first.')
if len({frame.size for frame in frames}) != 1:
raise ValueError('Frame dimensions must match.')
atlas = Image.new('RGB', (128 * len(frames), 128))
for i, frame in enumerate(frames):
atlas.paste(frame.resize((128, 128)), (128 * i, 0))
palette = atlas.quantize(colors=256)
converted = [
frame.quantize(palette=palette, dither=Image.Dither.NONE)
for frame in frames
]
if ping_pong:
converted += converted[-2:0:-1]
converted[0].save(
destination,
save_all=True,
append_images=converted[1:],
duration=int(duration_ms),
loop=0,
disposal=2,
optimize=False,
)
return str(destination)
Una paleta compartida reduce una posible fuente de parpadeo relacionado con la paleta.
Desactivar el dithering evita añadir un patrón de tramado durante la conversión, aunque la reducción de color puede introducir bandas.
La duración se mide en milisegundos y establecer loop=0 solicita reproducción continua. Con cuatro fotogramas, la reproducción ping-pong usa el orden 0, 1, 2, 3, 2, 1.
El corte inverso excluye los extremos repetidos. Esto no interpola movimiento: para una animación más suave hacen falta poses intermedias adecuadas, no solo otra velocidad de reproducción.
Reflexiones finales
Hemos creado un editor con Qwen Image 2.1 que acepta instrucciones de texto y dibujos opcionales, permite a los usuarios curar resultados individuales y los exporta como GIF.
La decisión clave de calidad fue mantener una referencia original fija en lugar de editar repetidamente salidas generadas.
Empieza con la configuración de muestreo que funciona, haz explícito el cambio solicitado e inspecciona los candidatos en bruto antes de tocar más ajustes.
Una vez que eso esté estable, prueba con la resolución o la decodificación variando una sola cosa cada vez. El resultado es un flujo de edición de imágenes útil, con una explicación clara de sus capacidades y limitaciones.
Preguntas frecuentes sobre Qwen Image 2.1
¿Puedo ejecutar esta demo en un A100 de Colab?
Sí. Ejecutamos el flujo de trabajo cuantizado de ComfyUI en una A100 con 40 GB de VRAM. Las peticiones finales usaron aproximadamente 19,6 GiB de memoria de GPU del backend muestreada a resolución 1024 y 40 pasos. Es una medición de nuestra configuración, no un requisito mínimo de hardware.
¿Tengo que dibujar una región antes de editar?
No. Puedes proporcionar solo una imagen y una instrucción de texto. Los círculos u otros contornos ayudan a identificar un objeto o parte del cuerpo específica. Aportan guía visual, pero no garantizan que los píxeles fuera de la región marcada permanezcan sin cambios.
¿Por qué cada edición parte de la imagen original?
En nuestros primeros experimentos se acumulaban artefactos cuando cada imagen generada se convertía en la siguiente entrada. Volver a la original evita arrastrar esos artefactos. Sin embargo, cada prompt debe describir el resultado completo deseado porque las ediciones anteriores no se conservan automáticamente.
¿Qwen Image 2.1 genera el GIF directamente?
No. Qwen genera imágenes editadas individuales y Pillow combina los fotogramas aceptados en un GIF. Los ajustes de reproducción controlan el tiempo y la dirección, pero no crean movimiento intermedio.
¿Qué ajustes debo cambiar para mejorar el resultado?
Empieza con una instrucción clara y una referencia limpia. Nuestra configuración usó 40 pasos, semilla 42, CFG 1, muestreo Euler, planificador simple y denoise 1. Son ajustes operativos, no valores óptimos probados. Cambia un ajuste cada vez y compara los PNG en bruto antes de juzgar el GIF.
Soy experta Google Developers en ML (Gen AI), triple experta en Kaggle y embajadora de Women Techmakers, con más de tres años de experiencia en el sector tecnológico. Cofundé una startup de salud en 2020 y actualmente curso un máster en informática en Georgia Tech, con especialización en aprendizaje automático.

Crear un GIF a partir de una imagen es bastante sencillo: le pides a un modelo de imagen una nueva pose, repites el proceso y unes las salidas a cierta velocidad. En la práctica, la estrategia de entrada importa tanto como el prompt. Cuando alimenté cada fotograma generado en la siguiente petición, las imágenes fueron acumulando artefactos poco a poco.
En este tutorial usaremos Qwen Image 2.1 para crear un editor interactivo que adopta un enfoque más fiable para este experimento. Cada petición parte de la imagen original. Los usuarios pueden describir un cambio, marcar opcionalmente el área relevante y aceptar o descartar el resultado antes de exportar un GIF.
Usaremos Qwen Image 2.1 para editar, ComfyUI para la inferencia, Gradio para la interfaz y Pillow para la exportación. Nos centraremos en las decisiones de diseño que influyeron en los resultados, como la selección de la referencia, la resolución, los parámetros de muestreo, la decodificación VAE y la precisión de las instrucciones.
Al final sabrás cómo: