Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Variações e Iterações

Aula 5 de 12 Atualizada a 2 de novembro de 2026 Programador
Nesta página
  1. Variações e Iterações
  2. Gerar Variações do Mesmo Conceito
  3. Variações Modificando o Prompt
  4. Iteração Refinando o Prompt
  5. Pipeline de Iteração Automatizada
  6. Comparar Variações num Catálogo
  7. A Disciplina da Iteração

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 modelos gpt-image-1.5, gpt-image-1-mini e chatgpt-image-latest serão aposentados em 1 de dezembro de 2026. Os exemplos agora utilizam o gpt-image-2.5-sunburst, que oferece a maior precisão para edição; o gpt-image-2.5-flare é mais rápido para geração padrão. Ambos os modelos suportam também as definições de qualidade xhigh e max. Os modelos GPT Image devolvem sempre imagens em base64: o parâmetro response_format dos 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
)

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.