Pular para o conteúdo principal

Tutorial Qwen Image 2.1: crie um editor de imagens e gerador de GIF

Aprenda a editar imagens com o Qwen Image 2.1 em um Colab A100, guiar mudanças com texto ou desenhos e exportar resultados selecionados como GIF.
· 12 min leer

Explore com IA

Criar um GIF a partir de uma única imagem é bem direto. Você pede a um modelo de imagem uma nova pose, repete o processo e junta as saídas em certa velocidade. Na prática, a estratégia de entrada importa tanto quanto o prompt. Quando alimentei cada quadro gerado no próximo pedido, as imagens começaram a acumular artefatos.

Neste tutorial, vamos usar o Qwen Image 2.1 para criar um editor interativo com uma abordagem mais confiável para este experimento. Cada solicitação parte da imagem original. O usuário descreve a mudança, opcionalmente marca a área relevante e pode aceitar ou descartar o resultado antes de exportar um GIF.

Vamos usar Qwen Image 2.1 para edição, ComfyUI para inferência, Gradio para a interface e Pillow para exportação. O foco está nas decisões de design que afetaram meus resultados, como seleção de referência, resolução, parâmetros de amostragem, decodificação VAE e instruções precisas.

Ao final, você vai saber como:

  • Executar um workflow quantizado do Qwen Image 2.1 em uma GPU A100 no Google Colab.
  • Configurar as definições de amostragem e memória usadas nesta demo.
  • Combinar instruções em texto com anotações de região opcionais.
  • Manter uma referência original fixa enquanto salva múltiplos quadros editados.
  • Avaliar mudanças indesejadas e exportar um GIF.

Notebook

O que é o Qwen-Image-2.1?

Qwen Image 2.1 é um modelo unificado de geração e edição de imagens.

Seu componente de geração visual tem 7 bilhões de parâmetros. O modelo suporta geração de texto para imagem, transparência nativa, múltiplas imagens de referência e edição local guiada por anotações ou máscaras. Este tutorial foca em edição RGB com uma única referência. 

O modelo já oferece a capacidade de edição. Nosso app adiciona o workflow em volta disso: selecionar a entrada, revisar candidatos, gerenciar quadros aceitos e exportá-los. Não estamos treinando um novo modelo nem adicionando um módulo de movimento.

O GIF resultante reproduz imagens estáticas geradas de forma independente. Ele pode demonstrar mudanças de pose e variações visuais, mas não equivale à geração de vídeo com consistência temporal.

Como o Qwen Image 2.1 funciona?

A descrição oficial da arquitetura identifica quatro componentes principais:

Componente

Especificação

Papel

Transformador visual

Transformador de difusão de fluxo único (DiT) com 32 camadas e 7B parâmetros

Processa os tokens de condicionamento e da imagem-alvo em um mesmo fluxo

Codificador de texto e imagem

Qwen3-VL 8B

Codifica instruções e imagens de referência em uma representação unificada

Autoencoder de imagem (VAE)

64 canais latentes, suporte a RGBA, compressão espacial de 16×

Converte imagens em latentes compactos e decodifica latentes gerados em pixels

Processo de geração

Flow matching com escalonamento Euler discreto e deslocamento dinâmico

Atualiza iterativamente os latentes da imagem-alvo rumo à imagem gerada

O transformador visual contém 7 bilhões de parâmetros. Essa contagem exclui o codificador de texto e imagem e o VAE. 

Os 64 canais do VAE se referem à sua representação latente, não a 64 canais de cor de saída. 

A saída RGBA contém canais vermelho, verde, azul e alfa. O app achata uploads para RGB, então não demonstra o suporte nativo do modelo à transparência.

Lendo o diagrama de atenção

O Qwen Image 2.1 usa uma máscara de atenção de granularidade mista: células coloridas permitem atenção, enquanto as cinzas a bloqueiam.

Qwen-Image-2.1 mixed-granularity attention architecture

Figura 1: arquitetura de atenção de granularidade mista do Qwen Image 2.1 (post no blog da Qwen)

Leia o diagrama por linha: Q representa os tokens de consulta (query) e K representa os tokens aos quais eles podem atender (attend). A sequência contém um prefixo do sistema, uma imagem de entrada opcional, uma instrução de edição e a imagem-alvo.

O texto usa atenção causal porque um token de texto pode atender a si mesmo e a posições anteriores. Tokens dentro do mesmo bloco de imagem podem atender uns aos outros em ambas as direções. 

Isso produz as regiões triangulares de texto e blocos sólidos de imagem mostrados na figura 1.

A regra da máscara expressa essa combinação como:

allowed = (q_idx >= kv_idx) or same_image_block

Esta é uma regra conceitual para um par de posições de tokens, não uma configuração extra para colar no notebook. Ela permite atenção a posições anteriores e libera atenção todos-para-todos dentro de cada bloco de imagem.

Por que um prefixo pode ser armazenado em cache?

O prefixo do sistema, a imagem de referência e a instrução não podem atender ao bloco posterior da imagem-alvo. 

Suas representações, portanto, não precisam mudar conforme a imagem-alvo é atualizada.

O Qwen calcula uma vez as chaves e valores de atenção deles no primeiro passo de denoising e os reutiliza nos passos seguintes. Os tokens da imagem-alvo ainda exigem computação a cada passo, atendendo ao prefixo em cache e entre si. 

Com 40 passos, o prefixo fixo pode ser reutilizado após o primeiro; isso não significa um ganho de velocidade de 40× porque ainda resta bastante computação na imagem-alvo.

Esse reaproveitamento de cache acontece entre os passos de denoising dentro de uma geração. Não significa que o modelo lembra pedidos anteriores do usuário nem que nosso app reutiliza automaticamente o mesmo cache entre edições enviadas separadamente. 

Demo: construindo um editor de imagens com o Qwen Image 2.1 

Antes de construir o app, vamos separar as configurações do modelo das decisões de aplicação. Note que aumentar o número de passos não corrige um pipeline que continua alimentando imagens danificadas de volta no modelo.

Configuração

Valor usado

Por que importa

Imagem de referência

Imagem original para cada edição no app final

Evita passar artefatos de um quadro gerado para o seguinte

Resolução

1024

Aproximadamente um alvo de edição de 1 megapixel neste backend

Passos de inferência

40

O orçamento de amostragem usado ao longo dos principais experimentos

Seed

42

Mantém a seed de amostragem fixa durante testes de instruções

CFG

1,0

Corresponde ao workflow fornecido; a orientação negativa padrão não contribui nesse valor

Sampler/scheduler

Euler / simple

Mantém a configuração de amostragem fornecida inalterada

Denoise

1,0

Condiz com este workflow de edição por instrução; não é uma receita img2img convencional de baixo denoise

Decodificação VAE

Sem tiling na configuração final

Selecionada após melhora qualitativa durante o desenvolvimento

Pesos

Modelo de imagem e codificador de texto INT8 ConvRot; VAE BF16

O backend econômico em memória usado na demo

Offload de encoder/cache de referência para CPU

Desativado inicialmente

A execução na A100 coube sem ativar essas opções adicionais de offload

Essas são configurações de trabalho para este projeto, não uma configuração globalmente ótima. Não fizemos uma varredura sistemática de passos, CFG, samplers ou formatos de quantização.

Os valores do sampler vêm do workflow de edição de imagem, que permitiu rodar este modelo com pouca VRAM. 

Passo 1: preparar o ambiente no Colab

A execução gravada usou uma NVIDIA A100-SXM4-40GB, com 83,5 GiB de RAM do host. 

Usei o pacote de instalação alesha-pro para instalar o ComfyUI e baixar os pesos quantizados.

Observe que você precisa planejar cerca de 45 GB de armazenamento livre, incluindo ambiente, modelos, caches e saídas. 

Uma execução com muita RAM dá folga durante carregamento e offload.

Primeiro, defina os caminhos e verifique a 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))

A checagem da GPU interrompe a execução se o Colab ainda estiver em runtime de CPU, e também imprimimos detalhes sobre a RAM do host e o espaço livre em disco antes da instalação. 

Os imports são básicos, incluindo bibliotecas padrão do Python, que cuidam de caminhos de arquivos, workflows em JSON, processos de backend, temporização e monitoramento em segundo plano. 

Pillow e NumPy tratam o processamento de imagens, Requests se comunica com o ComfyUI, Gradio fornece a interface e IPython exibe imagens no notebook.

Instale o backend separado da UI

O ComfyUI roda em seu próprio ambiente virtual. O kernel do notebook lida com uploads, requisições HTTP e o 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'])

Esse código busca a fonte fixada, lê sua configuração de versões, instala o backend, testa uma operação de tensor em CUDA e baixa os modelos.

A seleção do wheel de CUDA usa a versão do driver como heurística inicial. 

O smoke test de CUDA é uma verificação importante porque uma A100 por si só não garante compatibilidade com todas as builds do PyTorch. Minha sessão usou o driver 580.82.07.

Passo 2: iniciar o backend e definir parâmetros de inferência

A célula de inicialização lança o ComfyUI em 127.0.0.1:8188, espera ficar pronto e recupera as definições de nós disponíveis. 

O código se comunica com ele por meio de um pequeno 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()

Esse helper transforma falhas do servidor em exceções legíveis. Após a inicialização, o esquema de nós fica disponível via:

INFO = api('/object_info')

O código de inicialização verifica se já existe um servidor antes de lançar outro processo. Assim, não há um túnel público separado do ComfyUI nesta configuração.

Agora defina os parâmetros que usaremos para editar:

CPU_ENCODER = False
CPU_REFERENCE_CACHE = False
TILED_VAE = False
STEPS = 40
SIZE = 1024
SEED = 42

Veja como interpretar essas definições:

  • STEPS: Mais iterações de amostragem geralmente custam mais tempo. Usamos 40.
  • SIZE: No grafo de edição, resolução 1024 mira aproximadamente um megapixel enquanto adapta as dimensões à referência. Não força uma saída quadrada.
  • SEED: Uma seed fixa facilita comparações no mesmo setup. Não garante preservação de identidade nem transições suaves entre prompts diferentes.
  • TILED_VAE: A decodificação sem tiles processa a imagem sem o caminho de decodificação em tiles pequenos configurado. Pode exigir mais memória. Nossa preferência veio de testes visuais, não de uma prova controlada de que o tiling causou todos os artefatos.
  • Flags de offload para CPU: São controles de gerenciamento de memória, não de qualidade de imagem. Ative-os só quando necessário e meça a latência e o uso de RAM resultantes.

Da mesma forma, um negative prompt não é o principal controle para ajustar com CFG 1. Deixe-o vazio em vez de esperar que uma lista longa de propriedades indesejadas repare uma edição fraca.

Passo 3: conectar o prompt e a imagem de referência ao modelo

O construtor de workflow carrega um grafo de API e substitui suas entradas específicas do pedido. O trecho a seguir mostra o caminho de edição:

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'

Aqui, o nó 4 recebe a instrução de edição e a resolução. 

O nó 6 controla a amostragem e o nó 9 carrega a referência enviada. 

As outras duas substituições movem opcionalmente o encoder ou a cache de referência para a memória do host.

O helper de inferência então envia o grafo e aguarda seu próprio ID de requisição:

response = api('/prompt', {
    'prompt': g,
    'client_id': uuid.uuid4().hex,
})
result = collect_result(response['prompt_id'], folder)

Aqui, folder é o diretório de saída por requisição criado dentro de infer(). 

O coletor faz polling do histórico e baixa o PNG gerado quando o job correspondente termina.

Também salvamos a entrada, o grafo, o envio, o histórico e as métricas. Isso permite inspecionar a requisição real quando uma saída parece errada. 

Um timeout não cancela automaticamente o job na GPU, então guarde o ID da requisição antes de decidir tentar novamente.

Passo 4: preparar uma imagem original

O app final sempre precisa de uma referência inalterada para retornar. O caminho de upload abaixo aplica correção de orientação, achata a transparência e adiciona a imagem a uma tela quadrada antes de passá-la ao 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)

O padding preserva a proporção em vez de esticar o sujeito. Mas pode introduzir bordas. 

Um upload direto no editor do Gradio segue seu próprio manipulador de upload e pode manter as dimensões enviadas. Por isso o app também verifica as dimensões dos candidatos antes da exportação.

Para edição de pose, escolha uma imagem com espaço suficiente para o movimento solicitado e adicione uma instrução considerando o limite.

Passo 5: guie as edições com texto e desenhos

Um desenho é útil quando o alvo pode ser ambíguo, como escolher um dos braços ou um objeto em uma cena cheia. 

No nosso app, ele é completamente opcional. 

O editor do Gradio fornece o fundo, as camadas de desenho e a imagem composta; a regra importante para nosso design final é carregar o original e adicionar apenas as camadas de desenho:

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 é a lógica central dentro do callback de edição. 

O canal alfa revela se uma camada contém marcas visíveis, como um círculo, retângulo ou traço livre — todos podem servir como guia visual.

Essas marcas não são uma máscara rígida de inpainting. Elas indicam ao modelo onde focar, mas não garantem pixels inalterados no resto.

Podemos adicionar a explicação da região apenas quando existirem 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.'
)

A cláusula de preservação diz ao modelo o que importa, mas continua sendo uma instrução — não uma garantia. 

Para um teste mais explícito, especifique o lado relativo à imagem e a pose final, como:

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.'
)

Evite “mova um pouco mais” quando toda solicitação parte do original. 

O modelo não recebe a conversa anterior nem a última pose aceita.

Passo 6: gere cada candidato a partir do original

A primeira versão deste projeto gerava uma sequência alimentando cada saída no próximo pedido:

result = edit_frame(manifest['frames'][-1], POSES[pose_index])

image2.gif

Foi o comportamento que mudei no app final porque edições repetidas podem propagar artefatos, já que cada nova solicitação começa com a saída anterior do modelo. 

Na nossa sequência inicial da planta, imagens posteriores ficaram bem mais ruidosas.

O caminho final de geração usa a referência original, opcionalmente anotada, em vez disso:

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,
)

Isso remove o caminho de feedback por imagens previamente geradas. 

Não elimina artefatos em saídas individuais e não força que quadros gerados de forma independente combinem perfeitamente.

Se uma imagem aceita tem uma rosa, a próxima solicitação não a herda automaticamente. Para manter a rosa enquanto muda a pose, precisamos incluir ambos os 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.'
)

Esse trade-off é útil para gerar variações a partir de uma referência comum. 

Para tarefas que exigem edições cumulativas, um workflow sequencial pode continuar apropriado, mas com expectativas diferentes sobre mudanças acumuladas.

Passo 7: revise os candidatos antes de salvar

O app separa o original, a sequência aceita e o resultado pendente usando a função State do Gradio:

original_state = gr.State(initial_path)
frames_state = gr.State(initial_frames)
pending_state = gr.State(None)

A sequência começa com o original e só cresce quando o usuário aceita um candidato. O estado pendente guarda um arquivo gerado que ainda não foi aceito.

A operação central de aceitação é:

updated_frames = list(frames) + [pending_path]

Após essa atualização, o callback completo limpa o candidato pendente e o prompt, retornando o editor ao original.

Descartar limpa o resultado pendente sem alterar os quadros aceitos. Reset retorna a sequência a um único quadro original e limpa a instrução atual e a saída de download. Nenhuma ação exige recarregar o modelo.

Passo 8: construa o app no Gradio

A interface final separa edição, quadros salvos e exportação em três abas. 

Gradio app

O componente-chave é o editor de imagem:

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=(),
)

A cor fixa do pincel corresponde à instrução de anotação. 

A borracha permite refinar regiões grosseiras, enquanto transforms desativadas mantêm corte e rotação fora dessa interação.

O evento de geração passa o estado original para o 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,
)

Esses trechos de código pertencem ao layout completo do Blocks. 

O grupo de concorrência compartilhado serializa a geração e as mudanças de estado nesta demo. Reset espera sua vez; não é um controle de cancelamento de job na GPU.

Depois que os handlers e componentes estiverem definidos, lance o app executando:

demo.queue(default_concurrency_limit=1).launch(
    share=True,
    debug=True,
)

O link share do Gradio expõe o frontend, enquanto o backend permanece no localhost. Mudanças de tema e CSS melhoram a apresentação, mas não alteram a qualidade da imagem.

Passo 9: converter os quadros aceitos em um GIF

O exportador usa apenas os quadros aceitos porque cria uma paleta comum e, opcionalmente, reproduz a sequência de trás para frente após o quadro 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)

Uma paleta compartilhada reduz uma potencial fonte de flicker relacionado à paleta. 

Desativar dithering evita adicionar um padrão de dithering durante a conversão, embora a redução de cores ainda possa introduzir banding.

A duração é medida em milissegundos e definir loop=0 pede reprodução contínua. Para quatro quadros, o ping-pong usa a ordem 0, 1, 2, 3, 2, 1. 

O slice reverso exclui endpoints repetidos. Isso não interpola movimento: uma animação mais suave requer poses intermediárias adequadas, não apenas uma velocidade de reprodução diferente.

Considerações finais

Construímos um editor do Qwen Image 2.1 que aceita instruções em texto e desenhos opcionais, permite ao usuário curar resultados individuais e os exporta como GIF. 

A decisão de qualidade mais importante foi manter uma referência original fixa em vez de editar repetidamente saídas geradas.

Comece com a configuração de amostragem que funciona, torne a mudança solicitada explícita e inspecione os candidatos brutos antes de alterar mais configurações. 

Quando essas peças estiverem estáveis, experimente resolução ou decodificação, um variável por vez. O resultado é um fluxo de edição de imagens útil, com um relato claro de capacidades e limitações.

Perguntas frequentes sobre o Qwen Image 2.1

Posso rodar esta demo em um Colab A100?

Sim. Rodamos o workflow quantizado do ComfyUI em uma A100 com 40 GB de VRAM. As requisições finais usaram aproximadamente 19,6 GiB de memória de GPU do backend amostrada em resolução 1024 e 40 passos. Essa é uma medição da nossa configuração, não um requisito mínimo de hardware.

Eu preciso desenhar uma região antes de editar?

Não. Você pode fornecer apenas uma imagem e uma instrução em texto. Círculos ou contornos grosseiros ajudam a identificar um objeto ou parte do corpo específica. Eles fornecem orientação visual, mas não garantem que pixels fora da região marcada permaneçam inalterados.

Por que toda edição começa da imagem original?

Nossos primeiros experimentos acumularam artefatos quando cada imagem gerada virava a próxima entrada. Voltar ao original evita carregar esses artefatos adiante. Porém, cada prompt deve descrever o resultado completo desejado, pois edições anteriores não são retidas automaticamente.

O Qwen Image 2.1 gera o GIF diretamente?

Não. O Qwen gera imagens editadas individualmente, e o Pillow combina os quadros aceitos em um GIF. As definições de reprodução controlam tempo e direção, mas não criam movimento intermediário.

Quais configurações devo mudar para melhorar a saída?

Comece com uma instrução clara e uma referência limpa. Nossa configuração usou 40 passos, seed 42, CFG 1, amostragem Euler, scheduler simple e denoise 1. São definições de trabalho, não valores comprovadamente ótimos. Altere uma configuração por vez e compare os PNGs brutos antes de julgar o GIF.

Aashi Dutt

Autor

Aashi Dutt

Sou Especialista Google Developers em ML (Gen AI), tricampeã no Kaggle e Embaixadora Women Techmakers, com mais de três anos de experiência na área de tecnologia. Cofundei uma startup de saúde em 2020 e atualmente faço um mestrado em ciência da computação na Georgia Tech, com foco em aprendizado de máquina.

Temas

Relacionado

blog

O que é reconhecimento de imagens?