Gerar dez mil imagens com IA: o custo por imagem e o que faz ele despencar

Gerar uma imagem bonita é fácil. Gerar dez mil, com custo previsível e sem passar três dias esperando, é um problema de engenharia — e ele se resolve com quatro decisões que mudam o custo por imagem em vinte vezes.

Este texto é para quem tem uma lista: um catálogo de produtos, variações de campanha, miniaturas de conteúdo, dados sintéticos para treinar outro modelo.

De onde vem o custo

Gerar uma imagem por difusão é repetir uma operação pesada N vezes, partindo de ruído e limpando um pouco a cada passo. O custo é, quase literalmente:

Alavanca 1 — número de passos

É a que mais gente deixa no padrão e é a que mais pesa. Modelos clássicos pedem 30 a 50 passos. Modelos destilados (os que trazem "turbo", "lightning", "schnell" ou "flash" no nome) foram treinados para chegar a um resultado parecido em 4 a 8 passos.

Cinco vezes menos passos é, na prática, cinco vezes menos custo. A perda de qualidade existe e concentra-se em detalhe fino: textura de tecido, texto dentro da imagem, mãos. Para catálogo, fundo, miniatura e variação de campanha, é uma troca excelente.

Preços de agosto de 2026, para uma GPU avulsa, sem interrupção programada. O catálogo muda: confira a vitrine antes de fechar a conta.

Reparou que os números são todos ínfimos? Esse é o ponto que muda a estratégia: a dez mil imagens, a diferença entre a primeira e a última linha é R$ 85 contra R$ 7. Nenhum dos dois quebra ninguém. O que dói de verdade é o tempo: 30 horas de fila contra 2 horas e meia.

Alavanca 2 — resolução

O custo cresce com a área, não com o lado. Dobrar de 1024 para 2048 pixels multiplica o custo por quatro, não por dois.

A estratégia que quase sempre vence: gere em 1024 e amplie depois com um modelo de super-resolução, que é ordens de grandeza mais barato que gerar direto no tamanho grande. A imagem final fica indistinguível para uso em tela e em boa parte do impresso.

E gere no formato certo desde o início. Gerar quadrado para depois cortar em retrato joga fora 30% do que você pagou — e ainda corta a composição no lugar errado.

Alavanca 3 — lote

Mesmo raciocínio do servidor de texto: gerar 4 imagens numa passada aproveita muito melhor a placa do que 4 passadas de uma imagem. O ganho típico fica entre 2 e 3 vezes, até a VRAM encher.

Como achar o tamanho de lote certo: comece em 4, suba para 8, meça. Quando a memória estourar ou o ganho por imagem parar de melhorar, volte um passo. Em placa de 24 GB com modelo destilado, lote 4 a 8 costuma ser o ponto.

Alavanca 4 — não gerar a mesma imagem duas vezes

Parece óbvio e é o desperdício mais comum em fila grande: o processo cai na imagem 6.200 de 10.000, alguém reinicia e ele recomeça do zero. Ou a lista tem itens repetidos que ninguém filtrou.

Nomeie o arquivo de saída de forma determinística (a partir do texto do pedido e da semente) e pule o que já existe. Três linhas de código que salvam uma noite inteira de máquina.

O script de fila

pip install diffusers transformers accelerate torch --upgrade

import torch, hashlib, json
from pathlib import Path
from diffusers import AutoPipelineForText2Image

SAIDA = Path("saida"); SAIDA.mkdir(exist_ok=True)
LOTE = 4
PASSOS = 8

pipe = AutoPipelineForText2Image.from_pretrained(
    "SEU/modelo-destilado",
    torch_dtype=torch.bfloat16,
).to("cuda")
pipe.set_progress_bar_config(disable=True)

# lista de pedidos: [{"id": "sku-1234", "prompt": "..."}, ...]
pedidos = json.loads(Path("pedidos.json").read_text(encoding="utf-8"))

def caminho(p):
    chave = hashlib.sha1(f"{p['id']}|{p['prompt']}".encode()).hexdigest()[:12]
    return SAIDA / f"{p['id']}_{chave}.webp"

pendentes = [p for p in pedidos if not caminho(p).exists()]
print(f"{len(pendentes)} pendentes de {len(pedidos)}")

for i in range(0, len(pendentes), LOTE):
    grupo = pendentes[i:i + LOTE]
    imagens = pipe(
        prompt=[p["prompt"] for p in grupo],
        num_inference_steps=PASSOS,
        guidance_scale=0.0,          # modelos destilados: guidance 0
        height=1024, width=1024,
        generator=[torch.Generator("cuda").manual_seed(hash(p["id"]) % 2**31)
                   for p in grupo],
    ).images

    for p, img in zip(grupo, imagens):
        img.save(caminho(p), format="WEBP", quality=90)

    print(f"{min(i+LOTE, len(pendentes))}/{len(pendentes)}")

Onde a qualidade realmente quebra

Antes de rodar dez mil, gere trinta e olhe. Os problemas que aparecem em escala são sempre os mesmos:

• Texto dentro da imagem. Continua sendo o ponto fraco. Se o seu caso precisa de texto legível, componha por cima com um editor de imagem programático em vez de pedir ao modelo.
• Consistência entre itens. Dez mil imagens com iluminação e enquadramento diferentes não formam um catálogo. Fixe a parte do texto que descreve estilo, luz e ângulo e varie só o que muda.
• Repetição de rosto e de pose. Se o texto for genérico demais, o modelo cai nos mesmos padrões. Varie a semente e um adjetivo.
• Conteúdo indevido. Numa fila automática ninguém está olhando. Passe um classificador de segurança sobre a saída antes de publicar, sempre.

A conta de um catálogo real

Cenário: 10 mil produtos, três variações cada (30 mil imagens), 1024×1024, modelo destilado com 8 passos, lote 4, numa RTX 4090.

• Tempo: 30.000 × 0,9 s ≈ 7,5 horas
• Custo de GPU: 7,5 × R$ 2,78 ≈ R$ 21
• Ampliação para 2048 (opcional): +2 h ≈ R$ 6
• Revisão automática de segurança: incluída no mesmo processo

Menos de R$ 30 para trinta mil imagens. A conta que sobra é a de armazenamento e a de quem vai olhar a amostra — e essa é a que você não deve cortar.

Conclusão

Em geração de imagem, o custo por unidade é tão baixo que otimizar centavos é distração. O que importa é tempo de fila e consistência: use modelo destilado com poucos passos, gere em lote na resolução final certa, fixe a semente por item e torne a fila retomável.

E gere trinta antes de gerar trinta mil. O erro que custa caro não é o de configuração — é descobrir na entrega que as dez mil imagens têm o enquadramento errado.

Continue: modelos de imagem abertos · InvokeAI em 1 clique · trabalho em lote