Variações e Iterações
Nesta página
Atualizado em 2 de novembro de 2026 — Modelos de imagem. O modelo
gpt-image-1, para o qual este curso foi originalmente escrito, foi descontinuado em 23 de outubro de 2026. Além disso, os modelosgpt-image-1.5,gpt-image-1-miniechatgpt-image-latestserão aposentados em 1 de dezembro de 2026. Os exemplos agora utilizam ogpt-image-2.5-sunburst, que oferece a maior precisão para edição; ogpt-image-2.5-flareé mais rápido para geração padrão. Ambos os modelos suportam também as definições de qualidadexhighemax. Os modelos GPT Image devolvem sempre imagens em base64: o parâmetroresponse_formatdos modelos DALL·E mais antigos já não é aceite e foi removido do código. Fonte: Geração de imagens (OpenAI).
Variações e Iterações
Obter a imagem perfeita à primeira tentativa é raro. O trabalho real envolve gerar variações, compará-las e, em seguida, refinar progressivamente o prompt até alcançar o resultado desejado. Esta lição fornece-lhe as três ferramentas para este método: variação por reexecução, variação por modificação do prompt e iteração através de refinamento sucessivo.
Gerar Variações do Mesmo Conceito
O método mais simples é reexecutar a geração com o mesmo prompt: o GPT Image produz um resultado diferente todas as vezes. Isto é útil no início da exploração, quando ainda não sabe exatamente o que procura e deseja ver o leque de interpretações possíveis de uma ideia.
from openai import OpenAI
import base64
client = OpenAI()
def generate_variations(prompt: str, n_variations: int, prefix: str):
"""Gera várias variações independentes do mesmo prompt."""
paths = []
for i in range(n_variations):
response = client.images.generate(
model="gpt-image-2.5-sunburst",
prompt=prompt,
size="1024x1024",
quality="medium",
)
path = f"{prefix}_v{i+1}.png"
data = base64.b64decode(response.data[0].b64_json)
with open(path, "wb") as f:
f.write(data)
paths.append(path)
print(f"Variação {i+1} guardada: {path}")
return paths
variations = generate_variations(
prompt="Ilustração de um robô jardineiro a regar flores, estilo infantil e colorido",
n_variations=5,
prefix="gardener_robot"
)
Variações Modificando o Prompt
A abordagem anterior deixa-o à mercê do acaso; esta dá-lhe controlo. Fixa um sujeito invariante — aqui, uma chávena de café fumegante sobre uma mesa de madeira — e move apenas uma dimensão: o ambiente (mood). Os cinco resultados tornam-se então comparáveis, pois sabe exatamente o que os distingue. Esta é a diferença entre cinco tentativas e uma experiência.
from openai import OpenAI
import base64
client = OpenAI()
base_prompt = "Chávena de café fumegante sobre uma mesa de madeira"
moods = [
"luz suave da manhã, tons quentes",
"vibe de café parisiense, preto e branco",
"estilo pop art, cores saturadas",
"minimalismo escandinavo, fundo branco",
"atmosfera acolhedora de inverno, luzes de fada com bokeh",
]
for i, mood in enumerate(moods):
prompt = f"{base_prompt}, {mood}"
response = client.images.generate(
model="gpt-image-2.5-sunburst",
prompt=prompt,
size="1024x1024",
quality="medium",
)
path = f"cafe_mood_{i+1}.png"
data = base64.b64decode(response.data[0].b64_json)
with open(path, "wb") as f:
f.write(data)
print(f"Ambiente: {mood[:30]}... → {path}")
Iteração Refinando o Prompt
Quando o resultado não é satisfatório, a reação correta não é reexecutar e esperar por melhor sorte, mas sim adicionar a restrição em falta. A série abaixo mostra esta progressão num exemplo prático: “Um logótipo para uma startup de fintech” não diz nada ao modelo; a segunda iteração limita o número de cores e o fundo; a terceira nomeia a metáfora visual e a paleta; a quarta desce aos códigos hexadecimais e à espessura do traço. A cada passagem, o espaço de resultados possíveis estreita-se e a reprodutibilidade aumenta.
from openai import OpenAI
import base64
client = OpenAI()
iterations = [
# Iteração 1: prompt base
"Um logótipo para uma startup de fintech",
# Iteração 2: adição de restrições visuais
"Um logótipo para uma startup de fintech, design minimalista, no máximo duas cores, fundo transparente",
# Iteração 3: precisão de estilo
(
"Logótipo minimalista para uma startup de fintech, ícone geométrico abstrato "
"que evoca crescimento, paleta azul-marinho e verde-esmeralda, sem texto, estilo vetorial"
),
# Iteração 4: ajustes finos
(
"Logótipo minimalista para uma startup de fintech, ícone geométrico abstrato: "
"duas setas entrelaçadas formando um losango, azul-marinho (#1B2A4A) e "
"verde-esmeralda (#2ECC71), traço fino de 2px, fundo branco, renderização vetorial nítida, centrado"
),
]
for i, prompt in enumerate(iterations):
response = client.images.generate(
model="gpt-image-2.5-sunburst",
prompt=prompt,
size="1024x1024",
quality="high",
)
path = f"logo_iteration_{i+1}.png"
data = base64.b64decode(response.data[0].b64_json)
with open(path, "wb") as f:
f.write(data)
print(f"Iteração {i+1}: {prompt[:60]}...")
print(f" → {path}\n")
Pipeline de Iteração Automatizada
Num projeto ligeiramente mais longo, a memória humana não é suficiente: após quinze imagens, já não sabe qual prompt produziu qual resultado. O pipeline seguinte estrutura o trabalho em rondas, gera várias variantes por ronda, nomeia os ficheiros de forma rastreável e mantém o histórico completo dos prompts num ficheiro JSON. Este ficheiro de histórico é o que torna a configuração valiosa: permite-lhe recuar e capitalizar de um projeto para o seguinte.
from openai import OpenAI
import base64
import json
client = OpenAI()
def iteration_pipeline(brief: str, n_rounds: int = 3, n_per_round: int = 3):
"""
Pipeline de iteração: gera várias variantes por ronda,
mantém um histórico de prompts e resultados.
"""
history = []
current_prompt = brief
for round_num in range(1, n_rounds + 1):
print(f"\n{'='*50}")
print(f"RONDA {round_num} — Prompt: {current_prompt[:80]}...")
print(f"{'='*50}")
round_images = []
for i in range(n_per_round):
response = client.images.generate(
model="gpt-image-2.5-sunburst",
prompt=current_prompt,
size="1024x1024",
quality="medium",
)
path = f"pipeline_r{round_num}_v{i+1}.png"
data = base64.b64decode(response.data[0].b64_json)
with open(path, "wb") as f:
f.write(data)
round_images.append(path)
print(f" Variante {i+1}: {path}")
history.append({
"round": round_num,
"prompt": current_prompt,
"images": round_images
})
# Refinar o prompt para a próxima ronda
if round_num < n_rounds:
current_prompt += ", mais detalhes, melhor composição"
# Guardar o histórico
with open("pipeline_history.json", "w") as f:
json.dump(history, f, indent=2, ensure_ascii=False)
print(f"\nHistórico guardado: pipeline_history.json")
return history
iteration_pipeline(
brief="Ilustração de uma livraria independente vista de fora, noite de outono, estilo Ghibli",
n_rounds=3,
n_per_round=3
)
Comparar Variações num Catálogo
Abrir nove PNGs um por um num visualizador não permite qualquer comparação séria. Em vez disso, gere uma página HTML que os exiba lado a lado, com as imagens codificadas em base64 para que o ficheiro seja autónomo e partilhável tal como está com um cliente ou diretor de arte.
import base64
from pathlib import Path
from glob import glob
def generate_catalog(images: list[str], title: str, output: str = "catalog.html"):
"""Cria uma página HTML com todas as imagens lado a lado."""
html_parts = [
'<!DOCTYPE html><html><head><meta charset="utf-8">',
f'<title>{title}</title>',
'<style>',
'body { background: #111; color: #fff; font-family: sans-serif; padding: 2rem; }',
'.grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(300px, 1fr)); gap: 1rem; }',
'.card { background: #222; border-radius: 8px; overflow: hidden; }',
'.card img { width: 100%; display: block; }',
'.card p { padding: 0.5rem 1rem; font-size: 0.85rem; color: #aaa; }',
'</style></head><body>',
f'<h1>{title}</h1><div class="grid">',
]
for img_path in images:
with open(img_path, "rb") as f:
b64 = base64.b64encode(f.read()).decode()
html_parts.append(f'<div class="card">')
html_parts.append(f'<img src="data:image/png;base64,{b64}" />')
html_parts.append(f'<p>{Path(img_path).name}</p></div>')
html_parts.append('</div></body></html>')
with open(output, "w") as f:
f.write("\n".join(html_parts))
print(f"Catálogo gerado: {output}")
images = sorted(glob("pipeline_r*_v*.png"))
generate_catalog(images, "Variações — Livraria Ghibli")
A Disciplina da Iteração
Alguns princípios separam a iteração produtiva da tentativa e erro dispendiosa. Altere apenas um parâmetro de cada vez, caso contrário nunca saberá qual melhorou o resultado. Mantenha um histórico dos seus prompts e renderizações, como faz o pipeline acima, para capitalizar em vez de começar do zero em cada projeto. Trabalhe com quality: low durante toda a fase de exploração e mude para high apenas para a renderização final, ou pagará caro por imagens que vai deitar fora. Quando procura apenas diversidade rápida, prefira uma única chamada com o parâmetro n em vez de um ciclo de pedidos. Por fim, nomeie os seus ficheiros de forma descritiva: é um detalhe trivial no primeiro dia, decisivo após duzentas imagens.
Aplique agora esta sequência completa a um tema à sua escolha — logótipo, ilustração ou fotografia de produto. Gere três variantes com um prompt inicial, refine esse prompt à luz dos resultados, gere três novas variantes e, em seguida, produza o catálogo HTML comparativo das seis imagens.