Combinar a geração de imagens com outras ferramentas de API
Nesta página
- Combinar a geração de imagens com outras ferramentas de API
- Fazer com que um modelo de linguagem escreva o prompt
- Ilustrar um artigo de ponta a ponta
- Descrever uma imagem para a regenerar de forma diferente
- Processar grandes volumes em lotes
- Publicar diretamente no armazenamento
- 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 modelosgpt-image-1.5,gpt-image-1-miniechatgpt-image-latestserão aposentados a 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 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.