Geração de Imagens

A geração de imagens (image generation) é a família de técnicas de IA generativa (generative AI) que sintetizam novas imagens (ou editam imagens existentes) a partir de sinais de condicionamento (conditioning) como prompts de texto, imagens de referência, máscaras, esboços, mapas de profundidade ou poses. Sistemas modernos podem produzir cenas fotorrealistas, ilustrações, mockups de produto e arte estilizada — muitas vezes em segundos — ao aprender padrões a partir de conjuntos de dados de imagem–texto em larga escala.

Dois fluxos de trabalho (workflows) dominam o uso prático:

Texto-para-imagem (text-to-image, T2I): gerar uma imagem do zero guiada por um prompt de texto (e controles opcionais).
Imagem-para-imagem (image-to-image, I2I): gerar uma nova versão de uma imagem de entrada (variação, estilização, edição, inpainting/outpainting), muitas vezes ainda guiada por texto e outros controles.

Este artigo explica os conceitos-chave, os fundamentos de modelos e fluxos de trabalho práticos por trás de ambos.

O que “geração de imagens” significa na prática

A maioria dos geradores de imagem voltados ao usuário são modelos generativos condicionais (conditional generative models): eles amostram uma imagem (x) a partir de uma distribuição aprendida (p(x \mid c)), em que (c) é a informação de condicionamento (texto, imagem, máscara etc.). O condicionamento determina o que gerar, enquanto a aleatoriedade da amostragem (sampling) determina qual versão específica você obtém.

Tipos comuns de condicionamento incluem:

Prompts de texto (text prompts): “a cozy cabin in snowy woods at sunset, 35mm photo”
Prompts negativos (negative prompts): “blurry, extra fingers, watermark”
Imagens de referência (reference images): para preservar identidade/estilo/composição
Controles espaciais (spatial controls): mapas de bordas, mapas de profundidade, mapas de segmentação, esqueletos de pose humana
Máscaras (masks): para inpainting (editar apenas uma região)

A geração de imagens é uma entre várias modalidades na IA generativa; ela frequentemente se sobrepõe à Geração Multimodal quando modelos raciocinam conjuntamente sobre texto e imagens.

Fluxos de trabalho centrais: texto-para-imagem vs imagem-para-imagem

Texto-para-imagem (T2I)

O T2I normalmente começa a partir de ruído (ou um prior simples) e o refina iterativamente até chegar a uma imagem que corresponda ao prompt.

Um ciclo prático de T2I costuma se parecer com:

Escrever um prompt (e, opcionalmente, um prompt negativo).
Escolher resolução/proporção (aspect ratio) e uma semente (seed) aleatória.
Amostrar com um amostrador (sampler) escolhido e uma contagem de passos.
Revisar resultados; ajustar prompt ou configurações; amostrar novamente.
Opcionalmente fazer upscaling (upscaling) ou executar uma segunda passada de “refinador (refiner)”.

O T2I é ótimo para ideação e criação de novas composições, mas pode ser mais difícil controlar o layout com precisão sem ferramentas adicionais.

Imagem-para-imagem (I2I)

O I2I começa a partir de uma imagem existente e realiza uma transformação controlada. Um ciclo típico de I2I é:

Fornecer uma imagem de entrada.
Escolher uma “força de edição” (o quanto desviar).
Opcionalmente adicionar um prompt para direcionar estilo/conteúdo.
Opcionalmente fornecer uma máscara (inpainting) ou sinais de controle (pose/profundidade/bordas).
Amostrar e iterar até que a edição atenda aos requisitos.

O I2I costuma ser preferido em fluxos de produção porque preserva composição, identidade ou estrutura de marca de forma mais confiável do que o T2I.

Como modelos modernos representam imagens: espaço de pixels vs espaço latente

Gerar imagens em resolução total diretamente no espaço de pixels (pixel space) é caro. Muitos modelos amplamente usados geram em um espaço latente (latent space):

Um codificador (encoder) aprendido comprime uma imagem em um tensor latente (latent tensor) menor.
Um modelo generativo opera sobre latentes (mais barato, mais rápido).
Um decodificador (decoder) reconstrói a imagem RGB final.

Esse design de “difusão em espaço latente (latent diffusion)” é o motivo de muitas ferramentas conseguirem gerar imagens 1024×1024 em GPUs de consumo. Os latentes também facilitam adicionar controles modulares e ajustes finos (fine-tunings).

Conceito relacionado: Espaço Latente

Condicionamento: transformando texto e controles em orientação

A maioria dos geradores de imagem condicionados por texto usa:

Um codificador de texto (text encoder) (frequentemente no estilo CLIP (CLIP-like) ou no estilo T5 (T5-like)) para converter tokens de texto em incorporações (embeddings).
Um gerador (generator) (difusão/fluxo/transformador) que usa essas incorporações — comumente via atenção cruzada (cross-attention) — para orientar a geração.

Além de texto, modelos podem ser condicionados por:

Incorporações de imagem (image embeddings) (para transferência de estilo/identidade)
Mapas de controle (control maps) (pose/profundidade/bordas) injetados via redes laterais (por exemplo, designs do tipo ControlNet (ControlNet-like))
Máscaras para edições restritas a uma região

A qualidade do prompt importa, mas não se trata de “palavras mágicas” — e sim de fornecer restrições que o modelo consiga representar e com as quais consiga se alinhar. Veja também: Engenharia de Prompts

Famílias de modelos usadas para geração de imagens

Modelos de difusão (e parentes próximos): o motor de hoje

A maioria dos geradores de imagem de ponta, abertos e comerciais, é baseada em difusão ou deriva de ideias de difusão.

Noções básicas de difusão:

Processo direto (forward process): adicionar ruído gradualmente às imagens até que se tornem quase puro ruído.
Processo reverso (geração): aprender a remover ruído passo a passo, condicionado por texto/controles.

No momento da inferência (inference), você começa a partir de ruído e aplica repetidamente um desruidosador (denoiser) aprendido. O número de passos, o amostrador e as configurações de orientação (guidance) afetam qualidade, velocidade e aderência aos prompts.

Variantes modernas comuns:

Modelos de Difusão Latente (Latent Diffusion Models, LDMs): difusão em espaço latente comprimido.
Transformadores de Difusão (Diffusion Transformers, estilo DiT): transformadores como desruidosadores (frequentemente em escala).
Variantes destiladas/rápidas (distilled/fast variants): reduzem passos (por exemplo, abordagens no estilo consistência) para permitir geração quase em tempo real.
Treinamento por correspondência de fluxo (flow-matching) / estilo fluxo retificado (rectified-flow-style): intimamente relacionado à amostragem por difusão, mas formulado como aprendizado de um campo de velocidade; frequentemente usado para melhorar a eficiência de amostragem.

Modelos autorregressivos de tokens de imagem

Outra abordagem codifica imagens em tokens discretos (por exemplo, usando codificadores no estilo VQ (VQ-style encoders)) e então usa um transformador para prever tokens da esquerda para a direita (ou em blocos), de forma semelhante à Geração de Texto.

Prós:

Modelagem forte de verossimilhança (likelihood) no espaço de tokens
Integração natural com transformadores

Contras:

Contagens altas de tokens podem ser caras em alta resolução
A amostragem pode ser mais lenta sem esquemas de decodificação especializados

Relacionado: Arquitetura Transformer

GANs (Redes Adversariais Generativas)

GANs (Redes Adversariais Generativas (Generative Adversarial Networks, GANs)) treinam um gerador e um discriminador em competição. Elas historicamente dominaram a síntese fotorrealista e a transferência de estilo.

Prós:

Geração muito rápida em uma única passada (single-pass)
Saídas nítidas

Contras:

Dinâmica de treinamento mais difícil (instabilidade, colapso de modos (mode collapse))
Condicionamento menos flexível em comparação às cadeias de ferramentas da era da difusão

Relacionado: Redes Adversariais Generativas

VAEs (Autoencoders Variacionais)

VAEs (Autoencoders Variacionais (Variational Autoencoders, VAEs)) aprendem codificadores/decodificadores probabilísticos; sozinhos, eles frequentemente produzem imagens mais borradas, mas são componentes essenciais em pipelines de difusão latente (como codificador/decodificador latente).

Relacionado: Autoencoders Variacionais

Conceitos de amostragem que você realmente ajusta

Mesmo que você nunca treine um modelo, as configurações de amostragem afetam fortemente os resultados.

Semente (aleatoriedade)

Uma semente inicializa a aleatoriedade. Manter a mesma semente ao mudar prompts/configurações ajuda a isolar o que causou diferenças. Alterar a semente explora composições diferentes.

Passos e amostradores

Passos: mais passos frequentemente melhoram a fidelidade e reduzem artefatos, mas custam mais computação.
Amostrador: método numérico para o processo reverso (por exemplo, solvers (solvers) ancestrais vs determinísticos). Diferentes amostradores trocam velocidade vs textura/nitidez.

Orientação sem classificador (classifier-free guidance, CFG)

CFG aumenta o quão fortemente a saída corresponde ao condicionamento (prompt).

CFG baixo: mais diversidade, às vezes mais natural, menos fiel ao prompt
CFG alto: mais fiel ao prompt, mas pode introduzir artefatos ou contraste “passado do ponto”

Prompts negativos funcionam como condicionamento do tipo “o que evitar”, frequentemente implementado ao contrastar previsões incondicionais vs condicionais.

Resolução e proporção

Os modelos são treinados com certas distribuições de resolução. Forçar muito além disso (por exemplo, panoramas extremamente largos) pode reduzir a coerência, a menos que o modelo/ferramenta tenha sido projetado para isso.

Texto-para-imagem: um fluxo de trabalho prático (com exemplos)

Um bom fluxo de T2I é iterativo:

Declare sujeito + meio + estilo + contexto
Adicione detalhes de composição/câmera/iluminação se for fotorrealista
Adicione restrições (por exemplo, “no text, no watermark”)
Gere múltiplos candidatos (sementes diferentes)
Refine o prompt ou migre para I2I para edições controladas

Exemplos de prompts:

Fotorrealista:
- “Um retrato em close-up de um golden retriever usando óculos redondos, luz suave de janela, lente 85mm, profundidade de campo rasa, gradação de cor natural”
Ilustração:
- “Uma ilustração plana minimalista de uma bicicleta encostada em uma parede, paleta pastel, formas geométricas limpas, grande espaço negativo”
Mockup de produto:
- “Uma foto de produto em estúdio de uma garrafa de água preta fosca sobre um fundo branco infinito, iluminação de softbox, sombra sutil, ultra nítida”

Exemplo mínimo em Python (texto-para-imagem)

Below is an illustrative example using the Hugging Face diffusers API style (exact model IDs and parameters vary across releases and licenses):

import torch
from diffusers import AutoPipelineForText2Image

model_id = "stabilityai/stable-diffusion-xl-base-1.0"  # example
pipe = AutoPipelineForText2Image.from_pretrained(
    model_id, torch_dtype=torch.float16
).to("cuda")

prompt = "A cozy cabin in snowy woods at sunset, cinematic lighting, 35mm photo"
negative = "blurry, low quality, watermark, text"

image = pipe(
    prompt=prompt,
    negative_prompt=negative,
    width=1024,
    height=1024,
    num_inference_steps=30,
    guidance_scale=6.5,
    generator=torch.Generator("cuda").manual_seed(42),
).images[0]

image.save("t2i_cabin.png")

Notas operacionais:

Aumente num_inference_steps para melhorar a qualidade (até certo ponto).
Um guidance_scale moderado frequentemente gera imagens mais naturais do que valores muito altos.
Fixe a semente ao comparar revisões de prompt.

Imagem-para-imagem: variações, edições e transformações controladas

Imagem-para-imagem é melhor entendida como “geração com uma âncora”. A âncora pode ser uma imagem completa, uma região (máscara) ou um guia de estrutura.

Img2img padrão (variação / estilização)

No img2img baseado em difusão, a imagem de entrada é codificada em latentes e parcialmente ruidosa; em seguida, o modelo desruidosa guiado pelo prompt.

Parâmetro-chave: força (strength) (às vezes chamada denoising_strength), tipicamente em ([0, 1]):

Força baixa (por exemplo, 0.2–0.4): preserva composição/identidade; edições sutis
Força alta (por exemplo, 0.6–0.9): mudanças mais fortes; pode se afastar da fonte

Exemplos de casos de uso:

Converter uma foto em “ilustração em aquarela”
Mudar a hora do dia (“meio-dia” → “pôr do sol”)
Criar variações a partir de um esboço conceitual

Exemplo mínimo em Python (imagem-para-imagem)

import torch
from diffusers import AutoPipelineForImage2Image
from PIL import Image

init_image = Image.open("input.jpg").convert("RGB")

pipe = AutoPipelineForImage2Image.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    torch_dtype=torch.float16
).to("cuda")

prompt = "Same scene, but in the style of a watercolor illustration, soft edges"
image = pipe(
    prompt=prompt,
    image=init_image,
    strength=0.45,
    guidance_scale=6.0,
    num_inference_steps=30,
    generator=torch.Generator("cuda").manual_seed(7),
).images[0]

image.save("i2i_watercolor.png")

Inpainting: edite apenas parte de uma imagem

Inpainting usa uma máscara para especificar qual região pode mudar. Este é o fluxo de trabalho preferido para:

Remover objetos
Editar rostos/cabelos/roupas
Alterar regiões semelhantes a texto (com sucesso misto)
Corrigir artefatos (mãos, falhas no fundo)

Conceitualmente, o modelo regenera os pixels mascarados enquanto se condiciona pelo contexto não mascarado para manter coerência.

Exemplo (API conceitual; nomes exatos de classes variam):

import torch
from diffusers import AutoPipelineForInpainting
from PIL import Image

image = Image.open("scene.png").convert("RGB")
mask  = Image.open("mask.png").convert("L")  # white = replace, black = keep

pipe = AutoPipelineForInpainting.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    torch_dtype=torch.float16
).to("cuda")

prompt = "Replace the object with a small potted plant, realistic lighting"
result = pipe(
    prompt=prompt,
    image=image,
    mask_image=mask,
    guidance_scale=6.5,
    num_inference_steps=35,
).images[0]

result.save("inpaint_plant.png")

Dicas:

Mantenha a máscara bem ajustada ao que você quer mudar.
Descreva o que deve aparecer em vez de apenas o que remover.
Para realismo, combine a iluminação: “same lighting, same camera angle.”

Outpainting: estenda a tela

Outpainting é inpainting aplicado às bordas: expanda a imagem além do seu enquadramento original. É útil para:

Transformar um retrato em um banner mais largo
Estender fundos para cortes de vídeo
Gerar “mais da cena” no mesmo estilo

Controle de estrutura: pose, profundidade, bordas, segmentação

Prompts de texto sozinhos são fracos para especificar layout exato. Controles de estrutura lidam com isso ao condicionar em mapas espaciais:

Controle de pose: manter posições do corpo consistentes (arte de personagem, moda)
Controle de profundidade: preservar geometria da cena
Controle de bordas/rascunho: seguir um esboço ou line art
Controle de segmentação: impor posicionamento de objetos (céu/estrada/prédios)

Um padrão comum de implementação é uma rede lateral que injeta esses controles no desruidosador (frequentemente chamada de controle no estilo ControlNet (ControlNet-style)).

Conselho prático:

Use controle de estrutura quando você precisar de composição repetível (por exemplo, storyboards, mockups de UI).
Combine com inpainting para edições localizadas sem quebrar o layout global.

Personalização: ensinando um modelo sobre um sujeito ou estilo

Em produção, frequentemente é necessário consistência: o mesmo personagem, produto ou estilo de marca em muitas imagens. Métodos de personalização incluem:

Adaptadores LoRA (LoRA adapters): pesos leves ajustados finamente que podem ser ligados/desligados e combinados.
Relacionado: LoRA
Ajuste fino no estilo DreamBooth (DreamBooth-style fine-tuning): captura de identidade mais forte, mas com maior risco de sobreajuste (overfitting) e mais computação.
Inversão textual (textual inversion) / aprendizado de incorporações (embedding learning): aprender um novo “token” representando um conceito; tipicamente mais fraco do que LoRA para fidelidade de identidade.

Orientação prática:

Use LoRA quando precisar de modularidade e implantação simples.
Use ajuste fino mais forte quando o sujeito precisar ser extremamente consistente e você puder arcar com curadoria e avaliação cuidadosas.

Relacionado: Ajuste Fino

Aplicações: onde texto-para-imagem e imagem-para-imagem entregam valor

Usos comuns no mundo real incluem:

Arte conceitual e ideação: exploração rápida de estilos e composições
Marketing e produção criativa: visuais de campanha, mood boards, placas de fundo
Visualização de produto: mockups, conceitos de embalagem, variações de cor (com controles de marca)
Pipelines de jogos e filmes: variações de ambientes, conceitos de props, extensão de matte painting (outpainting)
E-commerce: substituição de fundo, edições localizadas, variações sazonais
Geração de dados sintéticos: aumentar conjuntos de dados para detecção/segmentação (com cuidado com a lacuna de domínio (domain gap))
Educação e comunicação: diagramas, visuais ilustrativos (com revisão humana)
Imagem médica/científica (com cautela): pesquisa de aumento (augmentation) e anonimização, tipicamente sob validação rigorosa

Para conteúdo consistente ao longo do tempo, os conceitos se estendem à Geração de Vídeo, em que a coerência temporal (temporal coherence) se torna o principal desafio adicional.

Avaliando a qualidade da geração de imagens (e por que é difícil)

Não existe uma única métrica que capture tudo o que usuários valorizam. A avaliação tipicamente combina:

Métricas automatizadas (úteis, mas limitadas)

FID (Distância de Inception de Fréchet (Fréchet Inception Distance)): mede similaridade de distribuição com imagens reais; pode não captar alinhamento com o prompt.
Inception Score: mais antiga; menos informativa para geração condicional.
CLIPScore / similaridade texto-imagem: estima alinhamento ao prompt, mas pode ser “enganada” (gamed) e pode não captar erros finos.
Preditores estéticos (aesthetic predictors): correlacionam com preferências humanas, mas incorporam vieses.

Avaliação humana (frequentemente necessária)

Humanos avaliam:

aderência ao prompt (“é o que eu pedi?”)
realismo/fidelidade (artefatos, anatomia)
composição e qualidade estética
consistência de marca/estilo
segurança e adequação

Em produção, equipes frequentemente criam rubricas (rubrics) e executam testes A/B em versões de modelo e prompts.

Modos de falha e limitações típicos

Mesmo modelos fortes exibem problemas recorrentes:

Erros de anatomia: mãos, dentes, joias; melhora com inpainting e controles melhores, mas não é eliminado
Renderização de texto: tipografia legível ainda é pouco confiável em muitos geradores
Contagem e restrições exatas: “exatamente 7 maçãs” pode falhar devido a raciocínio discreto fraco
Relações espaciais: “à esquerda de”, “atrás de”, “sob” pode ser inconsistente sem controles de estrutura
Consistência entre imagens: o mesmo personagem em cenas diferentes exige personalização + controle de pose/estrutura
Viés de conjunto de dados e estereótipos: saídas podem refletir dados de treinamento desbalanceados
Preocupações de PI/direitos autorais: saídas podem se parecer com exemplos de treinamento; políticas e ferramentas variam amplamente

Essas limitações são centrais para a implantação responsável e para decidir quando não usar geração de imagens.

Uso responsável: segurança, procedência e governança

Geradores de imagem podem ser usados para engano (deepfakes (deepfakes)), assédio ou uso indevido de PI. Estratégias comuns de mitigação incluem:

Filtros de conteúdo (classificadores de prompt e de saída)
Marcação d’água (watermarking) (visível ou invisível) e metadados de procedência (provenance metadata) (por exemplo, pipelines de assinatura (signing pipelines))
Políticas e licenciamento de modelo (restrições sobre ID biométrica, conteúdo explícito etc.)
Documentação de conjunto de dados e mecanismos de opt-out/consentimento quando aplicável
Revisão humana para domínios sensíveis (notícias, jurídico, médico)

Se você implantar geração de imagens em um produto, trate isso como um sistema sociotécnico (socio-technical system): segurança, UX, política e monitoramento importam tanto quanto a qualidade do modelo.

Relacionado: Segurança em IA

Orientação prática: escolhendo ferramentas e configurações

Ao selecionar uma abordagem, considere:

Necessidade de controle:
- Ideação livre → T2I
- Edições precisas → I2I + inpainting + controle de estrutura
Requisitos de consistência:
- Imagens pontuais → modelo base
- Sujeito/estilo repetidos → LoRA/ajuste fino + controles
Orçamento de computação e latência:
- Necessidades em tempo real → variantes destiladas/rápidas de amostragem, modelos menores, resolução menor
Licenciamento e implantação:
- Modelos com pesos abertos permitem implantação on-prem; APIs comerciais podem oferecer maior qualidade e ferramentas de segurança

Boas práticas operacionais:

Registre prompts, sementes, versões de modelo e configurações para reprodutibilidade.
Construa uma UI iterativa: gerar → selecionar → fazer inpainting → fazer upscaling/refinar.
Use verificações automatizadas para NSFW (not safe for work) e violações de política se prompts gerados por usuários forem permitidos.

Conexões com outras modalidades

A geração de imagens raramente existe sozinha em sistemas modernos:

Prompts de texto e refinamento iterativo se conectam fortemente à Geração de Texto (por exemplo, usar LLMs para redigir variantes de prompts).
Raciocínio conjunto de imagem–texto é abordado em Geração Multimodal.
Estender a geração de um único quadro para sequências consistentes no tempo leva à Geração de Vídeo.

A geração de imagens hoje é menos sobre um único modelo e mais sobre um fluxo de trabalho: condicionamento + amostragem + ferramentas de edição + controles + (opcionalmente) personalização. Entender esses blocos de construção torna muito mais fácil obter resultados confiáveis — e saber quando é provável que a tecnologia falhe.