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

Otimizar Custos

Aula 11 de 12 Atualizada a 2 de novembro de 2026 Programador
Nesta página
  1. Otimizar Custos
  2. Compreender a Estrutura de Custos
  3. Prototipar em Baixo, Entregar em Alto
  4. Nunca Pague Duas Vezes pela Mesma Imagem
  5. Dimensionar com Precisão
  6. Editar em Vez de Regenerar
  7. Saber Para Onde Vai o Dinheiro
  8. Por Onde Começar

Atualizado a 2 de novembro de 2026 — Modelos de imagem. O gpt-image-1, modelo para o qual este curso foi originalmente escrito, foi descontinuado a 23 de outubro de 2026. Os modelos gpt-image-1.5, gpt-image-1-mini e chatgpt-image-latest serão retirados a 1 de dezembro de 2026. Os exemplos utilizam agora 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 os níveis de qualidade xhigh e max. Os modelos GPT Image devolvem sempre imagens em base64: o parâmetro response_format dos modelos DALL·E antigos já não é aceite e foi removido do código. Fonte: Image generation (OpenAI).

Otimizar Custos

Em produção, a geração de imagens deixa de ser uma curiosidade técnica para se tornar uma rubrica orçamental. Qualquer equipa que produza algumas centenas de visuais por mês nota isso rapidamente. A primeira reação — restringir a utilização — é também a menos inteligente. Esta lição abrange cinco estratégias que reduzem as despesas sem comprometer a qualidade das suas entregas, pois visam aquilo que descarta e não aquilo que mantém.

Compreender a Estrutura de Custos

Os custos de geração dependem de três fatores.

FatorImpacto no Custo
Qualidade (low, medium, high)Multiplicador direto
Resolução (1024, 1536)Maior = mais caro
Número de imagens (n)Custo linear (n × preço unitário)

Estes três fatores multiplicam-se entre si, o que explica por que razão uma exploração indisciplinada custa uma ordem de grandeza superior à mesma exploração conduzida com disciplina. O script abaixo lista as cinco combinações que encontrará com mais frequência em produção. Embora os valores exatos apareçam no seu painel da OpenAI, a ordem das linhas já mostra a escala das compensações.

from openai import OpenAI

client = OpenAI()

# Compare costs: same prompt, different parameters
configs = [
    {"quality": "low", "size": "1024x1024", "label": "Low / 1024"},
    {"quality": "medium", "size": "1024x1024", "label": "Medium / 1024"},
    {"quality": "high", "size": "1024x1024", "label": "High / 1024"},
    {"quality": "medium", "size": "1536x1024", "label": "Medium / 1536"},
    {"quality": "high", "size": "1536x1024", "label": "High / 1536"},
]

print("Configuration         | Usage (estimated)")
print("-" * 50)
for config in configs:
    print(f"{config['label']:22s} | Check your OpenAI dashboard")

Prototipar em Baixo, Entregar em Alto

Esta é, de longe, a estratégia mais económica e a mais simples de adotar. Durante a fase de exploração, não está a julgar a finura de um gradiente: está a julgar a composição, o enquadramento e o ambiente geral, tudo perfeitamente visível em quality: low. Mudar para high só faz sentido para a imagem que realmente tenciona publicar. O fluxo de trabalho abaixo formaliza esta sequência, produzindo cinco rascunhos económicos seguidos de uma única renderização final, com a vantagem adicional de mudar para o formato paisagem (1536×1024) para a versão definitiva. Em cinco tentativas e uma entrega, as poupanças citadas no final do script rondam os 60% em comparação com uma exploração conduzida inteiramente em high.

from openai import OpenAI
import base64

client = OpenAI()

def economical_workflow(prompt: str, output: str, n_drafts: int = 5):
    """
    Two-phase workflow:
    1. Fast drafts in low quality
    2. Final render in high quality
    """
    # Phase 1: Fast exploration
    print("Phase 1: fast drafts (low quality)")
    drafts = []
    for i in range(n_drafts):
        response = client.images.generate(
            model="gpt-image-2.5-sunburst",
            prompt=prompt,
            size="1024x1024",
            quality="low",
        )

        path = f"draft_{i+1}.png"
        data = base64.b64decode(response.data[0].b64_json)
        with open(path, "wb") as f:
            f.write(data)
        drafts.append(path)
        print(f"  Draft {i+1}: {path}")

    # Phase 2: Final render (after human selection of the best draft)
    print("\nPhase 2: final render (high quality)")
    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt=prompt,
        size="1536x1024",
        quality="high",
    )

    data = base64.b64decode(response.data[0].b64_json)
    with open(output, "wb") as f:
        f.write(data)
    print(f"  Final render: {output}")

    # Summary: 5 low + 1 high instead of 5 high
    print(f"\nSummary: {n_drafts} low drafts + 1 final high")
    print("Estimated savings: ~60% compared to all-high exploration")


economical_workflow(
    "Illustration of a green tech campus with solar panels, architectural style",
    "campus_final.png"
)

Nunca Pague Duas Vezes pela Mesma Imagem

Numa aplicação real, o mesmo prompt surge muito mais frequentemente do que imagina: um utilizador a atualizar a página, um script de compilação a voltar a executar uma geração ou um ícone reutilizado em três páginas. Cada um destes casos representa uma cobrança desnecessária. A cache abaixo elimina-os calculando um hash SHA-256 do triplo (prompt, tamanho, qualidade) — os três elementos que determinam o resultado faturado — e truncando esse hash para dezasseis caracteres para criar um nome de ficheiro gerível. Note a verificação os.path.exists: o índice pode conhecer uma entrada cujo ficheiro foi apagado do disco; nesse caso, o código regenera a imagem em vez de devolver um caminho inválido.

import hashlib
import json
import os
from openai import OpenAI
import base64

client = OpenAI()

CACHE_DIR = "image_cache"
CACHE_INDEX = os.path.join(CACHE_DIR, "index.json")

def load_cache() -> dict:
    """Loads the cache index."""
    if os.path.exists(CACHE_INDEX):
        with open(CACHE_INDEX, "r") as f:
            return json.load(f)
    return {}

def save_cache(cache: dict):
    """Saves the cache index."""
    os.makedirs(CACHE_DIR, exist_ok=True)
    with open(CACHE_INDEX, "w") as f:
        json.dump(cache, f, indent=2, ensure_ascii=False)

def generate_with_cache(
    prompt: str,
    size: str = "1024x1024",
    quality: str = "medium"
) -> str:
    """Generates an image or returns the cached result."""
    # Create a unique key based on parameters
    key_data = f"{prompt}|{size}|{quality}"
    cache_key = hashlib.sha256(key_data.encode()).hexdigest()[:16]

    cache = load_cache()

    if cache_key in cache:
        cached_path = cache[cache_key]["path"]
        if os.path.exists(cached_path):
            print(f"Cache hit: {cached_path}")
            return cached_path
        else:
            print("Cache expired, regenerating...")

    # Not in cache: generate
    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt=prompt,
        size=size,
        quality=quality,
    )

    path = os.path.join(CACHE_DIR, f"{cache_key}.png")
    os.makedirs(CACHE_DIR, exist_ok=True)
    data = base64.b64decode(response.data[0].b64_json)
    with open(path, "wb") as f:
        f.write(data)

    cache[cache_key] = {
        "prompt": prompt[:100],
        "size": size,
        "quality": quality,
        "path": path
    }
    save_cache(cache)

    print(f"Generated and cached: {path}")
    return path


# First generation: API call
path1 = generate_with_cache("Minimalist logo for a tech startup, blue and white")
# Second identical call: served from cache
path2 = generate_with_cache("Minimalist logo for a tech startup, blue and white")

Dimensionar com Precisão

Gerar uma miniatura de alta resolução que será exibida num quadrado de 80 píxeis é como pagar por uma impressão de exposição apenas para a colocar numa carteira. A solução é deixar de deixar esta escolha ao arbítrio do programador e, em vez disso, derivá-la da utilização declarada. O dicionário generate_for_usage divide os casos em três famílias: formatos web pequenos — miniaturas e avatares — que funcionam bem com low; utilização web padrão — cabeçalhos de blogues, publicações sociais — que exigem medium; e suportes onde a finura realmente importa — banners principais, impressão A4, portefólios — que justificam high. As duas chamadas finais ilustram a diferença: o mesmo gato astronauta custa um múltiplo consoante acabe como miniatura ou como banner da página inicial.

from openai import OpenAI
import base64

client = OpenAI()

def generate_for_usage(prompt: str, usage: str, output: str):
    """Automatically chooses optimal resolution and quality."""
    configs = {
        # Small web usage
        "thumbnail": {"size": "1024x1024", "quality": "low"},
        "avatar": {"size": "1024x1024", "quality": "low"},

        # Standard web usage
        "blog_header": {"size": "1536x1024", "quality": "medium"},
        "social_post": {"size": "1024x1024", "quality": "medium"},

        # High-quality usage
        "hero_banner": {"size": "1536x1024", "quality": "high"},
        "print_a4": {"size": "1024x1536", "quality": "high"},
        "portfolio": {"size": "1024x1024", "quality": "high"},
    }

    config = configs.get(usage, {"size": "1024x1024", "quality": "medium"})

    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt=prompt,
        size=config["size"],
        quality=config["quality"],
    )

    data = base64.b64decode(response.data[0].b64_json)
    with open(output, "wb") as f:
        f.write(data)
    print(f"Usage {usage} ({config['quality']}/{config['size']}) → {output}")


generate_for_usage("Cute cat in an astronaut suit", "thumbnail", "cat_thumb.png")
generate_for_usage("Cute cat in an astronaut suit", "hero_banner", "cat_hero.png")

Editar em Vez de Regenerar

O cliente aprova a fotografia mas quer um céu diferente. O reflexo natural — voltar a executar a geração completa com um prompt ajustado — faz-lhe pagar por uma imagem inteira e, pior ainda, faz-lhe perder o resto da composição que todos tinham aprovado. A função images.edit() resolve esta situação pelo preço de uma edição: a função edit_detail constrói uma máscara que liberta apenas o retângulo relevante, aqui os 300 píxeis de altura superiores correspondentes ao céu, e o prompt descreve apenas o conteúdo dessa faixa. A paisagem em si não se move um único píxel.

import base64
from openai import OpenAI
from PIL import Image, ImageDraw

client = OpenAI()

# Instead of regenerating the entire image to change a detail,
# edit only the relevant area.

def edit_detail(image_path: str, zone: tuple, new_content: str, output: str):
    """
    Edits a detail in an existing image.
    zone: (x1, y1, x2, y2) of the area to modify
    """
    source = Image.open(image_path)
    mask = Image.new("RGBA", source.size, (0, 0, 0, 255))
    draw = ImageDraw.Draw(mask)
    draw.rectangle(zone, fill=(0, 0, 0, 0))
    mask.save("temp_mask.png")

    response = client.images.edit(
        model="gpt-image-2.5-sunburst",
        image=open(image_path, "rb"),
        mask=open("temp_mask.png", "rb"),
        prompt=new_content
    )

    with open(output, "wb") as f:
        f.write(base64.b64decode(response.data[0].b64_json))
    print(f"Detail edited: {output}")
    print("Cost: 1 edit instead of 1 full generation")


# Example: change just the sky of a photo
edit_detail(
    "landscape.png",
    (0, 0, 1024, 300),
    "Blue sky with some fluffy white clouds",
    "landscape_sky_edited.png"
)

Saber Para Onde Vai o Dinheiro

As quatro estratégias anteriores pressupõem que sabe o que está a consumir, e esta visibilidade não surge automaticamente: o painel do fornecedor dá-lhe um total, não uma desagregação por projeto ou qualidade. Um registo local colmata esta lacuna com um custo de desenvolvimento negligenciável. A função log_generation adiciona uma linha carimbada com data e hora para cada chamada, truncando o prompt para 100 caracteres para manter a legibilidade, e a usage_report agrega depois tudo por nível de qualidade. Esta desagregação desencadeia decisões: se o seu registo revelar que 80% das suas imagens são geradas em high enquanto a maioria acaba em publicações sociais, acabou de encontrar a sua reserva de poupança.

import json
import os
from datetime import datetime

USAGE_FILE = "image_usage_log.json"

def log_generation(prompt: str, size: str, quality: str, n: int = 1):
    """Logs every generation to track costs."""
    if os.path.exists(USAGE_FILE):
        with open(USAGE_FILE, "r") as f:
            log = json.load(f)
    else:
        log = []

    entry = {
        "timestamp": datetime.now().isoformat(),
        "prompt": prompt[:100],
        "size": size,
        "quality": quality,
        "n_images": n,
    }

    log.append(entry)

    with open(USAGE_FILE, "w") as f:
        json.dump(log, f, indent=2, ensure_ascii=False)


def usage_report():
    """Displays a consumption report."""
    if not os.path.exists(USAGE_FILE):
        print("No consumption data.")
        return

    with open(USAGE_FILE, "r") as f:
        log = json.load(f)

    total = len(log)
    by_quality = {}
    for entry in log:
        q = entry["quality"]
        by_quality[q] = by_quality.get(q, 0) + entry["n_images"]

    print(f"Total generations: {total}")
    print(f"Breakdown by quality:")
    for q, count in sorted(by_quality.items()):
        print(f"  {q}: {count} images")


usage_report()

Por Onde Começar

Nem todas estas estratégias oferecem o mesmo retorno pelo esforço despendido, e a tabela seguinte ajuda-o a defini-las por prioridade.

EstratégiaPoupança EstimadaEsforço
Baixo para prototipagem50-70%Mínimo
Cache de prompts10-30% (se repetitivo)Moderado
Resolução adaptada20-40%Mínimo
Edição vs. regeneração30-50% (por modificação)Moderado
Rastreio de despesasIndireto (visibilidade)Moderado

Duas linhas destacam-se claramente: prototipar em low e adaptar a resolução à utilização exigem um esforço mínimo para metade das poupanças possíveis. Comece por essas e adicione depois a cache e a edição direcionada quando o seu volume o justificar. O rastreio de despesas em si não poupa nada diretamente — mas é ele que lhe diz quais das outras quatro estão realmente a dar frutos no seu contexto específico.

A melhor forma de deixar de pensar nisto é encapsular estas regras num único ponto de controlo. Escreva um wrapper em torno de client.images.generate() que integre a cache de prompts, a adaptação automática da qualidade e da resolução com base na utilização declarada e o registo de cada chamada; execute-o depois em dez gerações e leia o relatório de consumo. A partir daí, toda a sua equipa poupa dinheiro sem ter de se lembrar de nada.