Apostila completa de Modelos de Difusão & ComfyUI
Esta apostila é a face técnica da geração de imagem — complementa o módulo de IA da apostila Ilustração, Imagem & Arte-direção com a mecânica: como a difusão funciona, os parâmetros (steps, CFG, sampler, seed), rodar localmente, o paradigma de grafo do ComfyUI, o controle fino (img2img, inpainting, ControlNet, IP-Adapter), treinar LoRAs, ir além da imagem estática, montar pipelines de produção, e a camada de direitos, ética e segurança que não é opcional.
Como modelos de difusão funcionam
Objetivo: a ideia central (adicionar e remover ruído), o espaço latente, o condicionamento por texto, e o panorama de modelos.
1.1 A ideia
- Forward process: pega uma imagem e adiciona ruído gaussiano em passos, até virar ruído puro.
- Reverse process: um modelo (uma U-Net ou um transformer) aprende a prever e remover o ruído passo a passo. Treinado em milhões de imagens, ele aprende "que ruído tirar" para revelar uma imagem plausível.
- Geração: começa de ruído aleatório e roda o reverse process N vezes (denoising steps), guiado por um texto, até sair uma imagem.
1.2 Latent diffusion
- Fazer isso nos pixels de uma imagem grande é caríssimo. Latent diffusion (a base do Stable Diffusion) trabalha num espaço latente comprimido: um VAE (autoencoder) reduz a imagem para um tensor pequeno; a difusão acontece ali; no fim, o VAE decodifica o latent de volta para pixels.
- Por isso "resolução" na verdade é o tamanho do latent, e o VAE afeta cores e detalhes finos.
1.3 Condicionamento por texto
- Um text encoder (CLIP, e/ou T5 nos modelos novos) transforma o seu prompt em embeddings que guiam cada passo de denoising (via cross-attention).
- Classifier-Free Guidance (CFG): roda o modelo com e sem o prompt e empurra o resultado na direção do prompt — o "guidance scale" controla a força (Módulo 2).
1.4 O panorama de modelos
| Modelo | Notas |
|---|---|
| SD 1.5 | antigo, leve (roda em 6–8 GB), ecossistema gigante de LoRAs/ControlNets; qualidade base modesta |
| SDXL | melhor qualidade e composição; ~12 GB; refiner opcional; muitos fine-tunes da comunidade |
| SD3 / SD3.5 | arquitetura de transformer (MMDiT), melhor texto e aderência ao prompt |
| Flux (Schnell/Dev) | alta qualidade e aderência, "Schnell" rápido/Apache, "Dev" com licença não-comercial por padrão — ler a licença |
| APIs fechadas | qualidade de topo, sem infra, mas com política de conteúdo, custo por imagem e menos controle |
O "melhor" muda a cada poucos meses; o que dura é entender os parâmetros e o controle (esta apostila) e avaliar no seu caso.
Geração de imagem de produto raramente é "prompt → resultado final". É gerar → controlar → refinar → integrar, quase sempre com um humano fechando o acabamento (ver Ilustração, Imagem & Arte-direção, Módulo 9). O valor está no pipeline e no controle, não no prompt mágico.
Perguntas de abertura: "Como um modelo de difusão gera uma imagem?" (parte de ruído e remove ruído passo a passo, guiado por um texto, até uma imagem plausível), "O que é latent diffusion e o VAE?" (a difusão acontece num espaço comprimido; o VAE codifica/decodifica para pixels), "O que é CFG / guidance scale?" (força com que o resultado é empurrado na direção do prompt), "Como você escolhe um modelo?" (VRAM, licença, ecossistema, e avaliar no caso — não o hype).
✏️ Exercício 1 — Explique o processo
Um colega diz "a IA baixa imagens da internet e mistura". Corrija a explicação em termos do que realmente acontece na geração, e diga onde entra o texto do prompt e onde entra a aleatoriedade.
Gabarito (uma boa resposta): o modelo não guarda nem "mistura" imagens — ele aprendeu, durante o treino, uma função que prevê o ruído a ser removido de uma imagem ruidosa. Na geração: começa-se de um tensor de ruído aleatório (a aleatoriedade vem da seed — a mesma seed + os mesmos parâmetros dão a mesma imagem); roda-se o modelo N vezes (steps), e a cada passo ele estima o ruído e o remove um pouco, revelando estrutura. O prompt, codificado por um text encoder, guia cada passo via cross-attention — puxa o denoising na direção de "uma imagem que combina com este texto" (com força dada pelo CFG). No fim, o VAE decodifica o latent para pixels. O que "vem da internet" é o aprendizado nos dados de treino (com todas as questões do Módulo 9), não uma cópia recuperada.
Os parâmetros que importam
Objetivo: prompt e negative prompt, steps, CFG, sampler/scheduler, seed, resolução — o que cada um faz e os trade-offs.
| Parâmetro | O que faz | Ponto de partida |
|---|---|---|
| Prompt | o que você quer; em modelos antigos, "tags" e ordem importam; nos novos, linguagem natural funciona melhor | descrever assunto, composição, luz, estilo, meio |
| Negative prompt | o que evitar (em modelos que o suportam) — "blurry, extra fingers, watermark" | usar com moderação; nos modelos novos é menos necessário |
| Steps | quantas iterações de denoising; mais = potencialmente mais detalhe, mais tempo, retorno decrescente | 20–30 (SDXL); alguns samplers/modelos convergem em 4–8 |
| CFG / guidance | força de aderência ao prompt; alto demais = "queimado", artefatos, menos natural; baixo = ignora o prompt | ~5–8 (SDXL); Flux usa "guidance" própria, valores diferentes |
| Sampler / scheduler | o algoritmo que resolve o processo reverso (Euler, Euler a, DPM++ 2M, DPM++ SDE, etc.) + o schedule de ruído (Karras, etc.) | DPM++ 2M Karras ou Euler; testar 2–3 |
| Seed | a semente do ruído inicial; fixar torna a geração reprodutível — essencial para iterar | fixar durante o refino; aleatória para explorar |
| Resolução / aspect ratio | o tamanho do latent; cada modelo tem uma faixa "nativa" (SD1.5 ~512, SDXL ~1024) — sair muito dela gera artefatos (corpos duplicados) | ficar na resolução nativa; upscale depois (Módulo 5) |
| VAE | afeta cor e detalhe fino no decode; alguns modelos precisam de um VAE específico | usar o VAE recomendado do modelo |
O erro nº 1 de quem começa é mudar prompt e seed ao mesmo tempo e não saber o que causou a mudança. Ao refinar, fixe a seed e mude uma coisa por vez (uma palavra do prompt, ou o CFG, ou o sampler). Quando achar a "base" boa, aí sim explore seeds.
Perguntas: "O que steps e CFG controlam e qual o trade-off?" (iterações de denoising × tempo/retorno decrescente; aderência ao prompt × "queimado"), "Por que fixar a seed?" (reprodutibilidade — iterar mudando uma variável por vez), "Por que não gerar direto em 4K?" (fora da resolução nativa do modelo → artefatos; gera na nativa e faz upscale), "O que o VAE afeta?" (cor e detalhe fino no decode).
✏️ Exercício 2 — Diagnóstico de parâmetros
Para cada sintoma, aponte o parâmetro provável e o ajuste: (a) a imagem parece "frita", com cores estouradas e contornos duros; (b) a composição ignora metade do prompt; (c) aparecem dois corpos / membros extras; (d) a imagem muda completamente a cada geração e você não consegue refinar; (e) a geração está lenta demais e o ganho de qualidade é mínimo.
Gabarito: (a) CFG alto demais → baixar (ex.: de 12 para 6–7); em Flux, ajustar a guidance própria. (b) CFG baixo demais ou prompt confuso → subir um pouco o CFG e reescrever o prompt priorizando o essencial no começo. (c) resolução fora da nativa (gerar 512 num modelo de 1024, ou um aspect ratio extremo) → gerar na resolução nativa e fazer upscale; usar "highres fix" / hires. (d) seed aleatória → fixar a seed para iterar. (e) steps altos demais (ex.: 80) → reduzir para 20–30, ou usar um sampler/modelo que converge em poucos passos.
Rodar localmente
Objetivo: o hardware (VRAM), as ferramentas (ComfyUI, Forge, diffusers), a otimização, e o trade-off local vs API.
3.1 Hardware
- VRAM é o gargalo: ~6–8 GB roda SD 1.5; ~10–12 GB roda SDXL confortável; Flux e vídeo pedem mais (16–24 GB+), com otimizações rodando em menos.
- NVIDIA/CUDA é o caminho suportado; Apple Silicon roda via MPS (mais lento) ou apps otimizados (Draw Things); AMD/ROCm com mais fricção.
- Sem GPU: possível na CPU, mas lento demais para uso real; ou serviços de GPU por hora.
3.2 As ferramentas
| Ferramenta | Perfil |
|---|---|
| ComfyUI | editor de grafo (nós); máximo controle, reprodutibilidade, automação, workflows compartilháveis — o padrão para produção (Módulo 4) |
| Automatic1111 / Forge | UI clássica de formulário; fácil de começar; Forge é otimizado |
| InvokeAI | UI polida, foco em fluxo criativo, canvas de inpainting |
| Fooocus | "só um prompt" — esconde a complexidade, bom para não-técnicos |
| diffusers (Hugging Face) | a biblioteca Python — para integrar em código/serviço (Módulo 8) |
3.3 Otimização
- Precisão: fp16 (padrão), fp8 (menos VRAM, leve perda) para modelos grandes.
- Atenção eficiente: xformers / SDPA; torch.compile; TensorRT para máxima velocidade em NVIDIA.
- Offload de partes do modelo para a RAM quando a VRAM não comporta (mais lento).
- Quantização de modelos grandes (GGUF para Flux, por exemplo) — ver IA Local & SLMs.
3.4 Local vs API
| Local | API |
|---|---|
| sem custo por imagem (depois do hardware); privacidade; controle total (LoRAs, ControlNet, sem filtro de conteúdo além do que você põe) | sem infra; qualidade de topo; escala instantânea |
| precisa de GPU e de operar; qualidade depende do modelo aberto | custo por imagem; política de conteúdo; menos controle fino; dados vão ao provedor |
Perguntas: "Quanta VRAM para SDXL / Flux?" (~12 GB SDXL; 16–24 GB+ Flux, menos com otimização/quantização), "Por que ComfyUI e não uma UI de formulário?" (grafo = controle, reprodutibilidade, automação, workflows compartilháveis), "Como acelerar a geração local?" (fp16/fp8, xformers/SDPA, torch.compile, TensorRT, quantização), "Local ou API — trade-offs?".
✏️ Exercício 3 — Escolha a stack
Para cada cenário, recomende ferramenta + local/API: (a) um designer explorando ideias, sem GPU potente; (b) um estúdio que precisa de 500 imagens/dia num estilo consistente e com dados de clientes confidenciais; (c) um dev integrando "gerar avatar" num produto SaaS; (d) alguém aprendendo a fundo como tudo funciona.
Gabarito (uma boa resposta): (a) API (ou Fooocus numa GPU alugada) — sem infra, foco na ideia; ou Draw Things no Mac. (b) ComfyUI local numa GPU boa — 500/dia via a API do ComfyUI, um LoRA de estilo próprio para consistência, e os dados dos clientes não saem (Módulo 8, 9). (c) API no MVP (rápido, escala) com atenção à política de conteúdo e ao custo; migrar para diffusers/ComfyUI self-hosted se o volume/custo/privacidade justificar (ver IA Local & SLMs para o padrão de cascata). (d) ComfyUI local — o grafo mostra cada etapa (checkpoint, CLIP encode, latent, sampler, VAE), e dá para inspecionar; complementar com a lib diffusers lendo o código.
ComfyUI: o paradigma de grafo
Objetivo: por que grafo, o workflow básico nó a nó, nós custom, versionar workflows como JSON, e rodar headless via API.
4.1 Por que grafo
- Cada etapa da geração é um nó com entradas e saídas; você liga os nós. Isso torna o pipeline explícito: você vê exatamente o que acontece e onde intervir.
- Reprodutibilidade: o workflow (JSON) + os parâmetros geram sempre o mesmo resultado; o ComfyUI embute o workflow no PNG gerado — arraste o PNG de volta e o grafo reaparece.
- Automação: o mesmo grafo roda 1 ou 10 mil vezes, via API, com inputs variando.
- Compartilhável: a comunidade troca workflows inteiros.
- Custo: curva de aprendizado maior que uma UI de formulário.
4.2 O workflow txt2img mínimo
Load Checkpoint → (MODEL, CLIP, VAE)
│
CLIP Text Encode (Prompt) ──┐
CLIP Text Encode (Negative) ──┤
│ ▼
Empty Latent Image (w,h,batch) → KSampler(model, positive, negative, latent,
│ seed, steps, cfg, sampler, scheduler, denoise=1.0)
│ │
▼ ▼
(nada) VAE Decode(latent, vae) → Save Image
- Load Checkpoint: carrega o modelo e expõe MODEL, CLIP, VAE.
- CLIP Text Encode: transforma o prompt (e o negativo) em conditioning.
- Empty Latent Image: cria o "canvas" latente (largura, altura, tamanho do batch).
- KSampler: o coração — roda o denoising com todos os parâmetros do Módulo 2.
- VAE Decode → pixels; Save Image (com o workflow embutido).
4.3 Nós custom
- Via ComfyUI Manager: ControlNet, IP-Adapter, upscalers, nós de vídeo, utilitários, integrações.
- Cuidado: nós custom são código de terceiros — instale de fontes confiáveis (é um vetor de risco, como qualquer plugin).
4.4 Versionar e automatizar
- Salve os workflows como JSON e versione em Git — um workflow é um artefato de produção.
- API: o ComfyUI expõe um endpoint HTTP/WebSocket; você envia o JSON do workflow (formato "API") com os inputs, ele enfileira e devolve as imagens. É assim que se integra num serviço (Módulo 8) ou num fluxo n8n (ver Automação com n8n).
- Headless: rodar sem a UI, num servidor com GPU.
Perguntas: "Por que ComfyUI usa grafo?" (pipeline explícito, reprodutível — workflow embutido no PNG, automatizável, compartilhável), "Descreva o workflow txt2img mínimo" (Load Checkpoint → CLIP encode positivo/negativo → Empty Latent → KSampler → VAE Decode → Save), "O que o KSampler faz?" (o denoising com seed/steps/cfg/sampler/scheduler/denoise), "Como você automatiza o ComfyUI?" (API com o JSON do workflow; headless num servidor GPU).
✏️ Exercício 4 — Leia o grafo
Um workflow tem, além do txt2img básico: um nó "Load LoRA" entre o checkpoint e o resto, um "Upscale Latent" entre o KSampler e o VAE Decode, e um segundo KSampler depois do upscale com denoise=0.5. Explique o que cada acréscimo faz e por que a ordem é essa.
Gabarito (uma boa resposta): Load LoRA logo após o checkpoint: aplica um adapter (estilo/personagem/objeto) ao MODEL e ao CLIP antes de qualquer encode/sample, para que toda a geração já seja "no estilo do LoRA". Upscale Latent após o primeiro KSampler: aumenta a resolução do latent (não dos pixels) — mais barato e mantém a coerência. Segundo KSampler com denoise=0.5: é o "hires fix" — re-roda o denoising na resolução maior, mas só parcialmente (0.5), então preserva a composição do primeiro passe e adiciona detalhe fino compatível com a nova resolução, sem inventar outra imagem. A ordem (gerar base em res nativa → upscale no latent → refinar parcial) é o padrão para sair da faixa nativa do modelo sem os artefatos de gerar direto em alta resolução (Módulo 2).
Controle: img2img, inpainting, ControlNet
Objetivo: guiar a geração pela estrutura — denoise strength, máscaras, ControlNet, IP-Adapter, regional prompting e upscale.
5.1 img2img e denoise strength
- Em vez de partir de ruído puro, parte-se de uma imagem (codificada pelo VAE) com ruído parcial. O denoise strength (0–1) controla quanto reinventar: 0.2–0.4 = pequenas mudanças de estilo/detalhe; 0.6–0.8 = mantém a composição, muda muito; 1.0 = ignora a imagem.
- Usos: refinar um rascunho, mudar o estilo de uma foto, iterar sobre uma geração.
5.2 Inpainting e outpainting
- Inpainting: uma máscara define a região a regenerar; o resto fica intacto — remover um objeto, trocar um elemento, consertar mãos.
- Outpainting: estender a imagem além das bordas (crop novo, formato diferente).
- Modelos/nós de inpainting dedicados dão melhor blend nas bordas.
5.3 ControlNet
- Uma rede auxiliar que condiciona a geração por uma estrutura extraída de uma imagem de referência: OpenPose (esqueleto — pose de pessoas), Depth (profundidade), Canny (bordas), Scribble (rabisco), Normal, Lineart, Segmentation.
- É o que dá composição consistente: você fixa a pose/o layout e varia o prompt/estilo. Essencial para produção (personagem na mesma pose em cenários diferentes, produto no mesmo ângulo).
- Parâmetros: força do controle, e em que intervalo de steps ele atua.
5.4 IP-Adapter
- Condiciona por uma imagem de referência (não por estrutura): "gere no estilo desta imagem" ou "com o rosto/objeto desta imagem". Combina com ControlNet.
- Base de: consistência de estilo entre um set, transferir a "vibe" de um moodboard, aproximar um personagem.
5.5 Regional prompting e upscale
- Regional prompting: prompts diferentes para regiões diferentes da imagem (o céu com um prompt, o primeiro plano com outro).
- Upscale: latent upscale + hires fix (Módulo 4); ESRGAN/modelos de super-resolução no espaço de pixels; tile upscale (Ultimate SD Upscale) para resoluções muito altas sem estourar a VRAM.
- O fluxo padrão: gerar base → (ControlNet/IP-Adapter para controle) → refinar (img2img parcial) → upscale → retoque manual.
Perguntas: "O que o denoise strength controla no img2img?" (quanto reinventar vs preservar a imagem de entrada), "O que é ControlNet e para que serve?" (condicionar pela estrutura — pose, profundidade, bordas — para composição consistente enquanto varia prompt/estilo), "ControlNet vs IP-Adapter?" (estrutura vs imagem de referência de estilo/conteúdo), "Qual o fluxo para uma imagem de qualidade de produção?" (base → controle → refino parcial → upscale → retoque humano).
✏️ Exercício 5 — Set consistente
Você precisa de 6 imagens do mesmo personagem (mesma roupa, mesmo rosto) em 6 cenários diferentes, para um material de marca. Descreva o pipeline de controle: o que fixa a consistência, o que varia, e como fecha o acabamento.
Gabarito (uma boa resposta): Consistência de personagem: um LoRA treinado no personagem (Módulo 6) é o mais robusto; alternativamente, um IP-Adapter com uma imagem de referência forte do rosto/roupa (+ IP-Adapter FaceID para o rosto). Pose/composição: para cada cenário, um ControlNet OpenPose (a partir de uma foto de referência ou de um rig de pose) fixa a postura, e um Depth se quiser controlar o enquadramento. O que varia: o prompt do cenário (fundo, luz, ação), talvez a seed. Base do modelo: um checkpoint SDXL/Flux estável, mesmos parâmetros (steps/CFG/sampler) nos 6. Refino: img2img parcial (denoise ~0.35) para uniformizar; inpainting do rosto em cada uma se ele "escorregar", usando a referência; upscale tile. Acabamento humano: um designer revisa os 6 lado a lado (a "grade da família" — ver Ilustração), corrige mãos/detalhes no Photoshop, ajusta a paleta aos tokens de cor da marca, e garante que parecem o mesmo personagem. Guardar prompt+seed+workflow de cada.
Customização: LoRA e embeddings
Objetivo: treinar um LoRA de estilo/personagem/objeto, textual inversion, o dataset, e os cuidados de licença e conteúdo.
6.1 As técnicas
| Técnica | Ensina | Tamanho |
|---|---|---|
| LoRA | um estilo, um personagem, um objeto, um conceito — a mais usada | alguns a dezenas de MB; aplica-se por cima de um checkpoint |
| Textual Inversion (embedding) | um "token" novo que representa um conceito, sem mudar o modelo | KB; menos potente que LoRA |
| DreamBooth | fine-tune mais completo de um sujeito (full ou via LoRA) | maior; melhor fidelidade, mais risco de overfit |
| Merge de modelos | combinar dois checkpoints (pesos) para um híbrido de estilo | o tamanho de um checkpoint |
Ver a apostila Fine-tuning e Customização de Modelos para o conceito de LoRA/PEFT em profundidade — aqui é a aplicação a imagem.
6.2 O dataset de um LoRA de imagem
- Poucas imagens: 10–30 para um personagem/objeto; 20–100 para um estilo. Qualidade e variedade > quantidade.
- Variedade: ângulos, iluminações, fundos, expressões — para o modelo aprender o sujeito, não o fundo.
- Captioning: descrever cada imagem (auto via um VLM + revisão), incluindo um trigger word único; descrever o que varia (fundo, pose) para o modelo separar isso do sujeito.
- Imagens de regularização (classe): imagens genéricas da categoria ("uma pessoa", "um carro") para o LoRA não "vazar" para tudo.
- Resolução consistente (buckets de aspect ratio).
- Treino: rank (16–64), learning rate, epochs — sinais de overfit (só gera a mesma pose, ignora o prompt). Ferramentas: kohya_ss, o trainer do ComfyUI, ai-toolkit (Flux).
6.3 Onde achar — e os riscos
- Civitai e afins têm milhares de LoRAs/checkpoints da comunidade. Riscos: licença (muitos não permitem uso comercial ou são de proveniência duvidosa), conteúdo (muito material NSFW e de semelhança de pessoas reais/artistas — ver Módulo 9), e segurança (arquivos
.ckptpodem conter código malicioso — prefira.safetensors). - Para trabalho profissional, prefira treinar o seu com um dataset que você tem direito de usar.
Perguntas: "Como você treina um LoRA de um personagem?" (10–30 imagens variadas do sujeito, captioning com trigger word descrevendo o que varia, imagens de regularização, rank moderado, poucas epochs, checar overfit), "LoRA vs textual inversion?" (LoRA muda pesos via adapter, mais potente; TI é só um token novo), "Riscos de baixar LoRAs do Civitai?" (licença, conteúdo de semelhança/artista, e .ckpt pode ter código — usar .safetensors).
✏️ Exercício 6 — Dataset de LoRA de estilo
Você quer um LoRA que reproduza o estilo de ilustração da sua marca (flat, 4 cores, sem textura — ver Ilustração). Descreva o dataset, o captioning, os parâmetros de partida, e como saberia que ficou bom (e não overfitado).
Gabarito (uma boa resposta): Dataset: 30–80 ilustrações já no estilo (as que o time produziu), variando assunto (pessoas, objetos, cenas), composição e paleta — para o modelo aprender o estilo, não um assunto. Todas em resolução consistente, fundo limpo. Captioning: cada uma com um trigger tipo marca_flat_style + descrição do conteúdo ("marca_flat_style, uma pessoa regando uma planta, fundo bege") — descrever o conteúdo faz o modelo atribuir o resto (as formas, as cores, a ausência de textura) ao trigger. Parâmetros: rank 16–32, LR moderado, 1500–3000 steps (ajustar), salvar checkpoints intermediários. Bom: com o trigger, qualquer assunto novo sai no estilo (formas flat, paleta, sem textura), e sem o trigger o modelo volta ao normal; funciona em resoluções e prompts variados. Overfit: repete composições/assuntos do dataset, ignora o prompt, "cola" elementos específicos das imagens de treino, ou o estilo "vaza" mesmo sem o trigger. Mitigar: menos steps, mais variedade no dataset, rank menor, imagens de regularização.
Além da imagem estática
Objetivo: geração de vídeo, animação, 3D, edição por instrução, e o problema difícil da consistência de personagem entre imagens.
7.1 Vídeo
- Text-to-video e image-to-video: modelos que geram clipes curtos (segundos), com o desafio central da consistência temporal (o objeto não "morfa" entre frames).
- Estado da arte: modelos de vídeo dedicados (fechados e abertos como os da linha open), cada vez melhores em coerência e controle (câmera, movimento).
- AnimateDiff (sobre SD): adiciona um módulo de movimento a um checkpoint de imagem — animações estilizadas, com ControlNet para controlar.
- Custo: muito maior que imagem (mais frames, mais compute); latência de minutos.
7.2 3D
- Image-to-3D / text-to-3D: gerar uma malha ou um Gaussian splat a partir de uma imagem/prompt — útil para protótipo, assets simples; qualidade ainda irregular para produção fina.
- Ver Blender 3D, Computação Gráfica & Three.js, Spatial Computing & WebXR.
7.3 Edição por instrução
- Modelos que editam uma imagem existente a partir de um comando ("troque o fundo por uma praia", "deixe o carro vermelho") — mantendo o resto. Os modelos "de edição" novos fazem isso com alta fidelidade, sem máscara.
- É o que o "generative fill" do Photoshop e ferramentas similares expõem (ver Photoshop 2026).
7.4 Consistência de personagem — o problema difícil
- Gerar "o mesmo personagem" em várias imagens sem treinar um LoRA é difícil. Abordagens: LoRA/DreamBooth (o mais confiável), IP-Adapter FaceID + referência forte, os recursos de "character reference" de alguns modelos, e — sempre — inpainting do rosto e retoque humano para fechar.
- Para um set (Módulo 5), combinar LoRA + ControlNet de pose + revisão na "grade da família".
Perguntas: "Qual o desafio central da geração de vídeo?" (consistência temporal — o conteúdo não morfar entre frames — e o custo/latência), "O que é AnimateDiff?" (módulo de movimento sobre um checkpoint de imagem), "Como manter um personagem consistente entre imagens?" (LoRA/DreamBooth como base, IP-Adapter FaceID, inpainting de rosto, retoque humano), "O que os modelos de 'edição por instrução' fazem?".
✏️ Exercício 7 — Vídeo curto de marca
O marketing quer um clipe de 4 segundos de um produto girando, com um "look" da marca, para um post. Descreva as opções (vídeo generativo vs animação 3D vs stop-motion de imagens), os trade-offs, e o que você recomendaria.
Gabarito (uma boa resposta): Opção A — image-to-video: gerar/fotografar uma imagem-chave do produto no look certo e usar um modelo de I2V para animar a rotação. Rápido, mas risco de o produto "morfar" (consistência temporal) e de a rotação não ser física; melhor para movimento sutil que giro completo. Opção B — 3D real (Blender, ver Blender 3D): modelar/usar o CAD do produto, materiais, e renderizar um giro perfeito com a iluminação da marca; mais trabalho, resultado controlável e "certo". Opção C — AnimateDiff / geração estilizada: se o look da marca é ilustrado, animar no estilo com ControlNet; coerente com a identidade. Recomendação: para um produto real que precisa girar corretamente, 3D (ou fotografia turntable) é o mais seguro; a geração de vídeo entra para elementos de fundo, transições e clipes onde a imperfeição não denuncia. Em todos: fechar a cor/grading nos tokens da marca (ver Cor), respeitar as regras de flash/reduced-motion se for para web, e o disclosure do Módulo 9.
Pipelines de produção
Objetivo: automatizar (ComfyUI API / diffusers), filas e workers de GPU, metadata e proveniência, controle de qualidade e custo.
8.1 Automatizar
- ComfyUI API: envie o JSON do workflow (formato "API") com os parâmetros variáveis (prompt, seed, imagem de entrada) → o servidor enfileira e devolve as imagens (via WebSocket/HTTP).
- diffusers (Python): montar o pipeline em código para máximo controle e para embutir num serviço.
- Orquestrar com um fluxo (n8n — ver Automação com n8n): trigger → montar o prompt/inputs → chamar o ComfyUI → pós-processar → entregar/notificar.
8.2 Serving de GPU
- Fila + workers: um ou mais workers com GPU puxando jobs de uma fila (Redis/SQS); um job = um workflow + inputs. Escala horizontal com mais workers.
- Modelos carregados: manter o checkpoint na VRAM entre jobs (não recarregar); trocar LoRAs/ControlNets é mais barato.
- Batch onde a latência permite; cache de resultados idênticos (mesmo prompt+seed+workflow).
- Ver IA Local, On-Device & SLMs (Módulo 9) para os padrões de serving.
8.3 Assíncrono e UX
- Geração leva segundos a minutos → rode em background, mostre progresso (steps), e notifique quando pronto (ver Design de Produtos com IA, Módulo 6). Nunca bloqueie a UI.
- Mostrar múltiplas opções (um batch), permitir regenerar (com custo visível), e ações a partir do resultado (baixar, usar, refinar).
8.4 Metadata e proveniência
- Grave no PNG (ou ao lado): prompt, negative, seed, steps, cfg, sampler, modelo + hash, LoRAs, o workflow inteiro — reprodutibilidade e auditoria. O ComfyUI já embute o workflow.
- C2PA / Content Credentials: assinar a imagem com sua proveniência ("gerada por IA com o modelo X") — cada vez mais esperado/exigido (Módulo 9).
- Watermark (visível e/ou inaudível/invisível tipo SynthID) conforme a política.
8.5 Controle de qualidade
- Filtros automáticos: NSFW classifier antes de entregar; detector de mãos/anatomia ruim (heurística ou um modelo) para rejeitar/reprocessar; checagem de que a imagem "bate" com o prompt (um VLM como juiz).
- Human-in-the-loop: as que passam nos filtros vão para curadoria antes de publicar; nada de IA "direto ao ar".
- Custo por imagem: tempo de GPU × preço; monitorar; oferecer modelos/steps mais baratos para exploração e caro só para o final.
Perguntas: "Como você põe geração de imagem em produção?" (ComfyUI API / diffusers + fila e workers de GPU com modelo carregado; background + notificação na UX; metadata e proveniência; QA com filtros + curadoria humana), "O que você guarda junto de cada imagem gerada?" (prompt, seed, parâmetros, modelo+hash, LoRAs, o workflow; C2PA), "Como controla a qualidade?" (NSFW filter, detector de anatomia, VLM checando aderência, human-in-the-loop).
✏️ Exercício 8 — Serviço de "gerar capa de artigo"
Um blog quer gerar automaticamente uma imagem de capa para cada artigo, no estilo da marca. Projete o pipeline: da publicação do artigo à imagem aprovada, incluindo QA, metadata e custo.
Gabarito (uma boa resposta): Trigger (n8n): artigo em rascunho. Montar o prompt: um LLM resume o artigo em um conceito visual (não literal — ver Ilustração), combinado com o trigger word do LoRA de estilo da marca e parâmetros fixos (SDXL/Flux, steps/CFG padrão). Gerar: chamar a API do ComfyUI (workflow versionado em JSON) num worker com GPU e o checkpoint já carregado; gerar um batch de 4 seeds. QA automático: filtro NSFW; um VLM checa se a imagem é coerente e sem texto ilegível/artefato grosseiro; descartar as ruins. Curadoria: as 2–3 melhores vão para o editor escolher (ou aprovar); nenhuma vai ao ar sem um humano. Pós: upscale + crop nos formatos (og:image, thumb), ajuste de cor aos tokens da marca. Metadata: gravar prompt+seed+workflow+modelo/hash; aplicar C2PA ("imagem assistida por IA") e, se a política pedir, uma marca "ilustração gerada". Custo: ~X s de GPU por batch → centavos por artigo; monitorar; usar um modelo mais barato para os drafts. Fallback: se a geração falha ou nada passa no QA, o artigo usa uma imagem do banco da marca.
Direitos, ética e segurança
Objetivo: o status legal (em disputa), consentimento e semelhança, NSFW/CSAM (obrigação de barrar), proveniência (C2PA), viés e watermarking.
9.1 Status legal — em disputa
- Treino com obras protegidas: há processos e posições divergentes em vários países; nada está "resolvido".
- Copyright do output: a proteção de uma imagem puramente gerada por prompt é incerta ou negada em alguns lugares (ex.: exige contribuição humana criativa suficiente); a parte que você retoca/compõe tende a ser sua.
- Ferramentas: alguns provedores oferecem indenização contratual e treino "licenciado/limpo"; outros não. Para trabalho comercial, verifique os termos (uso comercial permitido? quem detém a saída? há garantia?).
- Varia muito por país e muda rápido.
Esta seção é orientação prática de quem produz, não aconselhamento jurídico. Direito autoral, direito de imagem/voz, e regulação de IA (LGPD, o AI Act da UE, regras estaduais) variam por jurisdição e evoluem. Para uso comercial ou de cliente, envolva o jurídico e leia os termos de cada ferramenta.
9.2 Consentimento e semelhança
- Não gere semelhança de pessoas reais sem consentimento explícito e escopo — políticos, celebridades ou pessoas comuns. Deepfakes de pessoas são vetor de dano e cada vez mais ilegais.
- Não imite o estilo de um artista vivo identificável ("no estilo de [fulano]") — eticamente problemático e alvo de litígio.
- LoRAs de "semelhança" de pessoas reais são um dos maiores focos de abuso do ecossistema.
9.3 NSFW e CSAM
- CSAM (material de abuso sexual infantil): gerar, possuir ou distribuir é crime. Há obrigação legal e moral de barrar ativamente: filtros de prompt e de saída, hashing (PhotoDNA e afins), não treinar com datasets contaminados (houve casos), e reportar. Nenhum produto sério negocia isso.
- NSFW adulto: se o seu produto não é disso, filtre entrada e saída; o ecossistema aberto tem muito conteúdo desse tipo e ele "vaza" para modelos e LoRAs.
9.4 Datasets
- Modelos abertos foram treinados em datasets web massivos (LAION e outros) — que continham material com problemas de direito, de privacidade e, em casos documentados, ilegal (depois removido). Saber disso informa as escolhas de ferramenta e a comunicação honesta.
9.5 Proveniência, disclosure e watermarking
- C2PA / Content Credentials: um padrão de metadados assinados que registra que a imagem foi gerada/editada por IA e como — apoiado por vários provedores e ferramentas. Aplique.
- Watermarking invisível (ex.: SynthID) e/ou visível conforme o contexto e a regulação.
- Disclosure: dizer que o conteúdo é gerado/assistido por IA — exigido em vários contextos (publicidade, jornalismo) e crescente na regulação.
9.6 Viés e uso responsável
- Modelos reproduzem vieses do treino: profissões, tons de pele, gênero, corpos, contextos "padrão". Revise ativamente a representação e não aceite o default.
- Quando não usar geração: quando a autenticidade é o ponto (fotos reais de clientes, retratos, jornalismo factual), quando os direitos não são claros para o uso, quando há risco de dano (semelhança, desinformação), ou quando ilustração/foto humana entrega mais valor pelo mesmo custo (ver Ilustração, Imagem & Arte-direção).
Perguntas: "Qual o status legal de imagens geradas?" (treino e copyright do output em disputa/incertos, varia por país; a parte retocada tende a ser sua; verificar os termos da ferramenta — e que não é aconselhamento jurídico), "O que você barra ativamente?" (CSAM — obrigação legal; semelhança de pessoas reais sem consentimento; estilo de artista vivo), "O que é C2PA?" (metadados de proveniência assinados — "gerado/editado por IA"), "Como você lida com viés?" (revisar a representação, não aceitar o default).
✏️ Exercício 9 — Política de uso de geração de imagem
Uma agência vai adotar geração de imagem para trabalho de cliente. Escreva a política: o que é permitido, o que é proibido, o que se registra, e o que se comunica ao cliente e ao público.
Gabarito (uma boa resposta): Permitido: ideação e moodboards; fundos, texturas e elementos de apoio; um estilo próprio via LoRA treinado com dataset que a agência tem direito de usar; edição por instrução de imagens próprias/licenciadas; com acabamento humano na arte final entregue. Proibido: gerar semelhança de qualquer pessoa real sem consentimento por escrito; "no estilo de [artista vivo identificável]"; usar LoRAs/checkpoints de proveniência ou licença duvidosa; entregar output puramente gerado como "arte original" sem trabalho humano; qualquer conteúdo NSFW/ilegal (com filtros de entrada e saída, e CSAM barrado ativamente e reportado). Registrar: para cada asset entregável, o modelo+hash, os LoRAs, o prompt/seed/workflow, a ferramenta e sua licença, e quem fez a curadoria/retoque. Comunicar ao cliente: quais assets foram gerados/assistidos por IA, sob que ferramenta e termos, e as limitações de direito autoral do output (recomendando o parecer do jurídico do cliente). Ao público: aplicar C2PA e o disclosure exigido pelo contexto (publicidade, etc.). Revisão de viés na representação em toda peça com pessoas.
Mercado de trabalho: roadmap, entrevistas e portfólio
Objetivo: converter o conteúdo dos módulos em contratação — onde a habilidade é usada, um plano de estudo, um banco de perguntas e projetos que geram entrevista.
10.1 Onde essa habilidade pesa
- AI artist / concept artist (com IA no fluxo): ideação, iteração, produção assistida — com acabamento tradicional.
- Pipeline TD / creative technologist: montar workflows ComfyUI, automação, integração em produção.
- ML engineer (generative media): serving, fine-tune de LoRA/DreamBooth, avaliação, otimização.
- Product engineer em ferramentas criativas com geração embutida.
- Setores: publicidade, jogos, cinema/pré-viz, e-commerce, editorial, arquitetura.
10.2 Roadmap de estudo (5–7 semanas)
| Semanas | Foco | Prática |
|---|---|---|
| 1 | Como funciona + parâmetros (Módulos 1–2) | Gerar a mesma cena variando steps/CFG/sampler/seed e observar; fixar seed e iterar o prompt |
| 2 | Rodar + ComfyUI (Módulos 3–4) | Instalar ComfyUI; refazer o workflow txt2img do zero; salvar como JSON e rodar via API |
| 3 | Controle (Módulo 5) | img2img, inpainting de mãos, ControlNet OpenPose + Depth, IP-Adapter, um upscale tile |
| 4 | LoRA (Módulo 6) | Treinar um LoRA de um objeto/estilo com dataset limpo; avaliar overfit |
| 5 | Produção (Módulo 8) | Um mini-serviço: n8n → ComfyUI API → QA (NSFW + VLM) → metadata/C2PA → entrega |
| 6 | Vídeo + ética (Módulos 7, 9) | Um clipe com AnimateDiff/I2V; escrever uma política de uso responsável |
| 7 | Portfólio | Publicar os workflows, o LoRA, o serviço, e um estudo de fluxo híbrido IA→retoque |
10.3 Banco de perguntas (com a resposta que aprova)
Júnior/pleno — "Como um modelo de difusão gera uma imagem?"
Parte de ruído aleatório (da seed) e roda N passos de "remover ruído" — um modelo treinado para prever o ruído a tirar. O prompt, codificado por um text encoder, guia cada passo (com força dada pelo CFG). Latent diffusion faz isso num espaço comprimido; o VAE decodifica para pixels.
Pleno — "O que steps, CFG e seed controlam?"
Steps: número de iterações de denoising (mais tempo, retorno decrescente). CFG/guidance: aderência ao prompt (alto demais "queima", baixo ignora). Seed: a semente do ruído inicial — fixar torna a geração reprodutível para iterar mudando uma variável por vez.
Pleno — "Por que ComfyUI para produção?"
O grafo torna o pipeline explícito e reprodutível (o workflow é embutido no PNG e versionável como JSON), automatizável via API, e compartilhável. É o que permite rodar o mesmo pipeline 10 mil vezes com controle fino de cada etapa.
Pleno — "O que é ControlNet e quando você usa?"
Uma rede que condiciona a geração por uma estrutura extraída de uma referência — pose (OpenPose), profundidade, bordas (Canny), rabisco. Usa-se para composição consistente: fixar a pose/o layout e variar prompt/estilo — personagem na mesma pose em cenários diferentes, produto no mesmo ângulo.
Pleno — "Como você mantém um personagem consistente entre imagens?"
O mais confiável é um LoRA/DreamBooth do personagem; alternativas: IP-Adapter FaceID com referência forte, os recursos de character reference de alguns modelos. Sempre com inpainting do rosto onde "escorrega" e retoque humano fechando, e revisão dos resultados lado a lado.
Sénior — "Como você põe isso em produção com QA e proveniência?"
ComfyUI API / diffusers num worker com GPU (modelo carregado, fila); geração em background + notificação; filtros automáticos (NSFW, detector de anatomia, um VLM checando aderência); curadoria humana antes de publicar; gravar prompt/seed/parâmetros/modelo+hash/LoRAs/workflow em cada imagem; aplicar C2PA e o disclosure exigido. Monitorar custo por imagem.
Sénior — "Qual a situação de direitos e o que você barra?"
Treino e copyright do output estão em disputa e variam por país — a parte retocada/composta tende a ser sua, o output puro é incerto; verificar os termos da ferramenta (uso comercial, titularidade, indenização); não é aconselhamento jurídico. Barra-se ativamente: CSAM (obrigação legal), semelhança de pessoas reais sem consentimento, e imitação de artista vivo identificável. Aplicar C2PA e disclosure; revisar viés na representação.
Armadilha — "É só escrever o prompt certo"
Produção é gerar → controlar (ControlNet/IP-Adapter) → refinar (img2img parcial, inpainting) → upscale → retoque humano, com QA, metadata e proveniência. O prompt é uma pequena parte; o valor está no pipeline, no controle e na integração — e no julgamento humano que fecha.
10.4 Projetos de portfólio que geram entrevista
- Workflow ComfyUI documentado (âncora): um grafo que resolve um problema real (ex.: "produto no mesmo ângulo em 5 cenários" com ControlNet + IP-Adapter + upscale), com o JSON, o raciocínio de cada nó, e os resultados.
- LoRA de estilo próprio: treinado com um dataset limpo (que você tem direito de usar), com o processo de captioning, os parâmetros, e a demonstração de que generaliza sem overfit.
- Serviço de produção: n8n/diffusers → ComfyUI API → QA automático → metadata/C2PA → entrega, com custo por imagem medido.
- Estudo de controle: a mesma composição resolvida via ControlNet (pose + depth), mostrando consistência ao variar prompt e estilo.
- Fluxo híbrido: uma série onde a IA gerou a base e um humano fez o acabamento (vetorização, cor por tokens, retoque), documentando o que foi corrigido — em par com a apostila Ilustração, Imagem & Arte-direção.
10.5 Fontes para continuar
- Conceito: os papers de DDPM e Latent Diffusion (Stable Diffusion); a documentação da lib diffusers (Hugging Face); explicações visuais de difusão (Jay Alammar, "The Illustrated Stable Diffusion").
- ComfyUI: a documentação oficial, os workflows de exemplo, o ComfyUI Manager, e canais da comunidade.
- Controle e customização: os writeups de ControlNet e IP-Adapter; guias de treino de LoRA (kohya_ss, ai-toolkit); Civitai (com os cuidados do Módulo 9).
- Proveniência/ética: a especificação C2PA / Content Credentials; materiais sobre watermarking e detecção; a apostila Governança de IA, Ética & EU AI Act.
- Nesta trilha: Ilustração, Imagem & Arte-direção (o lado de design), Fine-tuning e Customização de Modelos, IA Local, On-Device & SLMs, Design de Produtos com IA, Automação com No-Code & n8n, Criação e Edição de Vídeos com IA, Photoshop 2026, Cor, Segurança de Aplicações de IA.
Cinco ideias sustentam geração de imagem por difusão: (1) o modelo remove ruído passo a passo guiado por um texto, num espaço latente — e seed + parâmetros tornam isso reprodutível; (2) fixe a seed e mude uma variável por vez; gere na resolução nativa e faça upscale; (3) o ComfyUI (grafo) dá controle, reprodutibilidade e automação — e a produção é gerar → controlar (ControlNet/IP-Adapter) → refinar → upscale → retoque humano; (4) LoRA é a via de customização (estilo/personagem), com dataset limpo e sem overfit; (5) a camada de direitos, consentimento, C2PA e barrar CSAM/semelhança não é opcional — e o acabamento e o julgamento continuam humanos.