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

Combinar a geração de imagens com outras ferramentas de API

Aula 10 de 12 Atualizada a 2 de novembro de 2026 Programador
Nesta página
  1. Combinar a geração de imagens com outras ferramentas de API
  2. Fazer com que um modelo de linguagem escreva o prompt
  3. Ilustrar um artigo de ponta a ponta
  4. Descrever uma imagem para a regenerar de forma diferente
  5. Processar grandes volumes em lotes
  6. Publicar diretamente no armazenamento
  7. O que mantém um pipeline de pé

Atualização de 2 de novembro de 2026 — Modelos de imagem. O modelo gpt-image-1, 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 aposentados a 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 não é suportado e foi removido do código. Fonte: Geração de imagens (OpenAI).

Combinar a geração de imagens com outras ferramentas de API

Isoladamente, a geração de imagens é uma ferramenta artesanal: escreve um prompt e obtém um ficheiro. O seu verdadeiro poder emerge quando se torna num passo de uma cadeia automatizada — um modelo de linguagem que escreve o prompt, uma análise de visão que descreve uma imagem de referência ou um armazenamento que publica o resultado. Esta lição mostra-lhe como interligar estas peças.

Fazer com que um modelo de linguagem escreva o prompt

Os seus utilizadores ou colegas não escrevem prompts visuais; escrevem briefings. «Preciso de uma imagem para um artigo sobre IA na saúde, futurista mas humana» não contém composição, iluminação ou paleta. Em vez de lhes pedir que aprendam o vocabulário da lição anterior, insira um modelo de linguagem para tratar da tradução. Atribua-lhe o papel de diretor de arte na mensagem do sistema e exija que produza as camadas específicas do prompt, com instruções estritas para não devolver mais nada. Caso contrário, receberá uma explicação educada que teria depois de enviar ao GPT Image.

from openai import OpenAI
import base64

client = OpenAI()

def text_to_image(brief: str, output: str):
    """
    Pipeline de dois passos:
    1. Um LLM gera o prompt visual ótimo
    2. O GPT Image cria a imagem
    """
    # Passo 1: Gerar o prompt visual com um LLM
    completion = client.chat.completions.create(
        model="gpt-5.6-luna",
        messages=[
            {
                "role": "system",
                "content": (
                    "You are an expert art director. "
                    "Based on a brief, generate a detailed prompt for an "
                    "image generation model. Include: subject, composition, lighting, "
                    "style, perspective, color palette. "
                    "Respond only with the prompt, no explanation."
                )
            },
            {"role": "user", "content": brief}
        ]
    )

    visual_prompt = completion.choices[0].message.content
    print(f"Generated prompt: {visual_prompt[:100]}...")

    # Passo 2: Gerar a imagem
    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt=visual_prompt,
        size="1536x1024",
        quality="high",
    )

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


prompt = text_to_image(
    "I need an image for an article on artificial intelligence "
    "in healthcare. Futuristic but human.",
    "ai_health.png"
)

Ilustrar um artigo de ponta a ponta

Um artigo de destaque necessita de uma imagem de capa e de uma ilustração por secção. Estas imagens devem parecer coesas sem serem idênticas. A função illustrate_article aplica esta lógica, reinjetando o estilo em cada prompt e repetindo o título do artigo de cada vez, conferindo unidade temática ao conjunto completo. Dois detalhes de poupança de custos merecem atenção: a capa é gerada com qualidade high porque todos a veem e é frequentemente partilhada, enquanto as ilustrações das secções permanecem em medium, já que são exibidas menores e mais abaixo na página. Para as cinco secções neste exemplo sobre IA no recrutamento, esta compensação reduz a fatura sem que o leitor note qualquer diferença.

from openai import OpenAI
import base64
import json

client = OpenAI()

def illustrate_article(title: str, sections: list[str], style: str, output_dir: str = "."):
    """
    Gera uma ilustração de cabeçalho + uma por secção.
    """
    results = []

    # Imagem de capa
    header_prompt = (
        f"Cover image for an article titled \"{title}\", "
        f"{style} style, panoramic composition, "
        "no text in the image, professional"
    )

    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt=header_prompt,
        size="1536x1024",
        quality="high",
    )

    path = f"{output_dir}/header.png"
    data = base64.b64decode(response.data[0].b64_json)
    with open(path, "wb") as f:
        f.write(data)
    results.append({"type": "header", "path": path})
    print(f"Header: {path}")

    # Ilustrações das secções
    for i, section in enumerate(sections):
        section_prompt = (
            f"Illustration for the section \"{section}\" "
            f"of an article on \"{title}\", "
            f"{style} style, rectangular format, "
            "conceptual illustration without text"
        )

        response = client.images.generate(
            model="gpt-image-2.5-sunburst",
            prompt=section_prompt,
            size="1536x1024",
            quality="medium",
        )

        path = f"{output_dir}/section_{i+1}.png"
        data = base64.b64decode(response.data[0].b64_json)
        with open(path, "wb") as f:
            f.write(data)
        results.append({"type": f"section_{i+1}", "section": section, "path": path})
        print(f"Section {i+1} ({section[:30]}...) : {path}")

    return results


illustrate_article(
    title="5 Ways AI Is Transforming Recruitment",
    sections=[
        "Automatic CV Screening",
        "AI-Analyzed Video Interviews",
        "Smart Candidate-Job Matching",
        "Reducing Recruitment Bias",
        "Personalized Onboarding",
    ],
    style="3D isometric illustration, blue and violet tones",
    output_dir="."
)

Descrever uma imagem para a regenerar de forma diferente

Como obter uma versão de inverno de uma paisagem de verão quando só tem o ficheiro, sem máscara e sem ferramentas de edição? Passe pela linguagem. A visão do modelo analisa a imagem e produz uma descrição suficientemente precisa para servir de prompt de reconstrução — assunto, composição, iluminação, cores, estilo, perspetiva, atmosfera. Concatena depois a sua instrução de modificação a esta descrição. O modelo de geração recebe um prompt de texto completo onde apenas a estação mudou, e obtém uma imagem coerente com a original em vez de algo sem relação. Esta é também a forma mais fiável de reproduzir a identidade visual de uma imagem de referência que não pode editar diretamente.

from openai import OpenAI
import base64

client = OpenAI()

def analyze_and_vary(image_path: str, instruction: str, output: str):
    """
    1. Analisa uma imagem com o GPT Vision
    2. Gera uma variante baseada na análise
    """
    # Passo 1: Analisar a imagem
    with open(image_path, "rb") as f:
        image_b64 = base64.b64encode(f.read()).decode()

    analysis = client.chat.completions.create(
        model="gpt-5.6-luna",
        messages=[
            {
                "role": "user",
                "content": [
                    {
                        "type": "text",
                        "text": (
                            "Describe this image in detail so an image "
                            "generation model can reproduce it faithfully. "
                            "Include: subject, composition, lighting, colors, style, "
                            "perspective, mood. Be very precise."
                        )
                    },
                    {
                        "type": "image_url",
                        "image_url": {
                            "url": f"data:image/png;base64,{image_b64}"
                        }
                    }
                ]
            }
        ]
    )

    description = analysis.choices[0].message.content
    print(f"Analysis: {description[:150]}...")

    # Passo 2: Gerar uma variante modificada
    variant_prompt = f"{description}. Requested modification: {instruction}"

    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt=variant_prompt,
        size="1024x1024",
        quality="high",
    )

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


analyze_and_vary(
    "original_landscape.png",
    "Change the season from summer to winter, with snow on roofs and trees",
    "winter_landscape.png"
)

Processar grandes volumes em lotes

Gerar cinco visuais de produto em série demora minutos; gerar quinhentos sequencialmente leva a noite toda e falha ao primeiro soluço da rede. A configuração abaixo resolve ambos os problemas. Cada tarefa é um dicionário autónomo que transporta o seu ID, prompt, ficheiro de saída e definições. A função worker envolve a chamada num bloco try que devolve um estado em vez de derrubar todo o lote: uma geração rejeitada não deita abaixo as outras quatrocentas e noventa e nove. O ThreadPoolExecutor paraleliza então a execução, mas com um max_workers deliberadamente baixo — três neste exemplo — porque o gargalo não é a sua máquina, são as quotas da API. O relatório final conta sucessos e falhas para que saiba o que repetir.

from openai import OpenAI
import base64
import json
import time
from concurrent.futures import ThreadPoolExecutor, as_completed

client = OpenAI()

def generate_one_image(task: dict) -> dict:
    """Gera uma única imagem a partir de uma tarefa."""
    try:
        response = client.images.generate(
            model="gpt-image-2.5-sunburst",
            prompt=task["prompt"],
            size=task.get("size", "1024x1024"),
            quality=task.get("quality", "medium"),
        )

        data = base64.b64decode(response.data[0].b64_json)
        with open(task["output"], "wb") as f:
            f.write(data)

        return {"id": task["id"], "status": "ok", "path": task["output"]}

    except Exception as e:
        return {"id": task["id"], "status": "error", "error": str(e)}


def batch_generation(tasks: list[dict], max_parallel: int = 3):
    """Executa um lote de gerações com paralelismo controlado."""
    results = []

    with ThreadPoolExecutor(max_workers=max_parallel) as executor:
        futures = {
            executor.submit(generate_one_image, task): task
            for task in tasks
        }

        for future in as_completed(futures):
            result = future.result()
            results.append(result)
            status = result["status"]
            print(f"  [{status}] {result['id']}")

    # Relatório
    ok = sum(1 for r in results if r["status"] == "ok")
    errors = sum(1 for r in results if r["status"] == "error")
    print(f"\nFinished: {ok} ok, {errors} errors out of {len(tasks)} tasks")

    return results


# Definir um lote de tarefas
tasks = [
    {
        "id": f"product_{i}",
        "prompt": f"E-commerce product photo: {product}, white background, studio",
        "output": f"batch_product_{i}.png",
        "quality": "high"
    }
    for i, product in enumerate([
        "rose gold watch",
        "aviator sunglasses",
        "braided leather bracelet",
        "solitaire diamond ring",
        "cultured pearl necklace",
    ])
]

results = batch_generation(tasks, max_parallel=3)

Publicar diretamente no armazenamento

Escrever o PNG no disco da máquina que executa o script só faz sentido em desenvolvimento. Em produção, a imagem deve chegar onde o seu site a vai buscar, e o desvio pelo sistema de ficheiros local torna-se num ponto de falha desnecessário. O formato b64_json adapta-se bem a esta remoção: os bytes descodificados são envolvidos num objeto BytesIO e enviados diretamente para o bucket, com um ContentType explícito — sem o qual os browsers ofereceriam um download em vez de exibir a imagem. A função devolve o URL público, que é aquilo de que o seu CMS realmente precisa.

from openai import OpenAI
import base64
import boto3
from io import BytesIO

client = OpenAI()

def generate_and_store_s3(prompt: str, bucket: str, key: str):
    """Gera uma imagem e carrega-a diretamente para o S3."""
    response = client.images.generate(
        model="gpt-image-2.5-sunburst",
        prompt=prompt,
        size="1024x1024",
        quality="high",
    )

    image_data = base64.b64decode(response.data[0].b64_json)

    s3 = boto3.client("s3")
    s3.upload_fileobj(
        BytesIO(image_data),
        bucket,
        key,
        ExtraArgs={"ContentType": "image/png"}
    )

    url = f"https://{bucket}.s3.amazonaws.com/{key}"
    print(f"Image stored on S3: {url}")
    return url


# Exemplo
url = generate_and_store_s3(
    "Mobile app icon: open book with stars, flat design",
    "my-image-bucket",
    "generated/app_icon_v1.png"
)

O que mantém um pipeline de pé

Os cinco pipelines desta lição partilham a mesma higiene de construção. Cada passo faz uma coisa, permitindo-lhe substituir a escrita do prompt ou o armazenamento sem tocar no resto. Cada passo trata dos seus próprios erros; caso contrário, uma recusa de moderação no meio de um lote deita abaixo toda a cadeia — é exatamente isso que o try em generate_one_image previne. O paralelismo mantém-se limitado para respeitar os limites de taxa e, neste ponto, a cautela custa menos do que a recuperação após uma proibição temporária.

Restam dois hábitos menos visíveis, mas igualmente decisivos. Registe os prompts realmente enviados, especialmente quando escritos por um modelo de linguagem: sem este registo, uma imagem de que gosta torna-se irreproduzível na segunda execução. E coloque resultados em cache sempre que o mesmo prompt possa retornar, o que a próxima lição formalizará num sistema completo.

Agora monte a sua própria cadeia completa: ela recebe um título de artigo como entrada, pede a um modelo de linguagem três descrições de visuais relevantes, gera as três imagens em paralelo e produz um JSON de resumo que liga cada prompt ao seu ficheiro. Terá então tudo o que precisa para ilustrar um blog inteiro sem intervenção manual.