Moderação e Segurança de Conteúdo Visual
Nesta página
- Moderação e Segurança de Conteúdo Visual
- O Sistema de Moderação Integrado
- Pré-filtragem de Prompts
- Verifique Também as Imagens Geradas
- Quando os Utilizadores Escrevem os Prompts
- Registos para Responsabilização
- Direitos de Autor e Marcas Registadas
- Conformidade com o RGPD
- Antes de Abrir as Comportas
- Teste os Seus Conhecimentos
Atualizado em 3 de novembro de 2026 com base no guia Geração de imagens da OpenAI: uma recusa de moderação é identificada por
error.code == "moderation_blocked", com um objeto opcionalmoderation_details, e não pela presença das palavrassafetyoucontent_policyna mensagem de erro; adicionado o parâmetromoderation(auto,low). Fonte: Geração de imagens.
Atualização de 2 de novembro de 2026 — Modelos de imagem. O
gpt-image-1, no qual este curso foi originalmente escrito, foi descontinuado em 23 de outubro de 2026, e ogpt-image-1.5,gpt-image-1-miniechatgpt-image-latestserão aposentados em 1 de dezembro de 2026. Os exemplos agora utilizamgpt-image-2.5-sunburst, o mais preciso para edição; ogpt-image-2.5-flareé mais rápido para geração padrão. Ambos aceitam também as qualidadesxhighemax. Os modelos GPT Image devolvem sempre a imagem em base64: o parâmetroresponse_formatdos modelos DALL·E antigos não é aceite e foi removido do código. Fonte: Geração de imagens (OpenAI).
Moderação e Segurança de Conteúdo Visual
Enquanto gerar imagens apenas para si próprio, a moderação é uma questão de julgamento pessoal. Assim que abrir a geração aos utilizadores, torna-se numa responsabilidade legal e ética que o vincula. Esta lição abrange as ferramentas de moderação da OpenAI, como encadeá-las em filtros sucessivos e as medidas que protegem tanto a sua aplicação como as pessoas que a utilizam.
O Sistema de Moderação Integrado
O GPT Image recusa certos conteúdos por si só — violência, material sexualmente explícito, entre outros — e sinaliza essa recusa com um erro específico. O seu código deve, portanto, distinguir uma recusa por política de conteúdo de uma falha técnica, pois as duas exigem reações opostas: a primeira resulta numa mensagem ao utilizador, a segunda num alerta à sua equipa. A documentação da OpenAI especifica o discriminador a utilizar: uma recusa de moderação chega como um BadRequestError com error.code igual a moderation_blocked (tipo image_generation_user_error), e o corpo do erro pode conter um objeto moderation_details que especifica a fase (input, output ou unknown) e categorias gerais (harassment, sexual, violence…). Não procure palavras na mensagem de erro: o texto não é um contrato, o código sim. A função abaixo relança a exceção apenas se não se tratar de uma recusa de moderação.
from openai import OpenAI, BadRequestError
client = OpenAI()
def generate_with_moderation(prompt: str, output: str) -> dict:
"""Gera uma imagem enquanto gere recusas de moderação."""
try:
response = client.images.generate(
model="gpt-image-2.5-sunburst",
prompt=prompt,
size="1024x1024",
quality="medium",
)
import base64
data = base64.b64decode(response.data[0].b64_json)
with open(output, "wb") as f:
f.write(data)
return {"status": "ok", "path": output}
except BadRequestError as e:
if e.code != "moderation_blocked":
raise # falha técnica, quota, pedido inválido: tratar noutro local
body = e.body if isinstance(e.body, dict) else {}
details = body.get("moderation_details") or {}
return {
"status": "refused",
"reason": "Conteúdo recusado pela política de segurança",
"stage": details.get("moderation_stage"), # input, output ou unknown
"categories": details.get("categories") or [], # para os seus registos
}
result = generate_with_moderation(
"A kitten playing with a ball of yarn",
"kitten.png"
)
print(result)
A OpenAI aconselha manter uma mensagem genérica para o utilizador final e reservar o moderation_details para os seus registos e suporte. Estes erros não se resolvem com nova tentativa: sem modificar o prompt ou as imagens fornecidas, o mesmo pedido será novamente recusado. Note finalmente que a severidade do filtro é definida pelo parâmetro moderation dos modelos GPT Image: auto (filtragem padrão, predefinido) ou low (menos restritivo).
Pré-filtragem de Prompts
Esperar que o GPT Image recuse um prompt antes de descobrir que era problemático é insatisfatório: já consumiu a chamada à API e não aprende nada de específico sobre o motivo. A API de Moderação, no entanto, é gratuita, rápida e devolve categorias nomeadas. Chamá-la antes da geração permite-lhe recusar de forma limpa, explicar ao utilizador o que foi assinalado e manter esta informação para a sua auditoria. A função verify_prompt extrai a lista de categorias acionadas, e generate_safe_image simplesmente encadeia os dois passos: verificar primeiro, gerar depois.
from openai import OpenAI
client = OpenAI()
def verify_prompt(prompt: str) -> dict:
"""Verifica um prompt com a API de Moderação antes da geração."""
moderation = client.moderations.create(
model="omni-moderation-latest",
input=prompt
)
result = moderation.results[0]
if result.flagged:
categories_flagged = [
cat for cat, flagged in result.categories.__dict__.items()
if flagged
]
return {
"allowed": False,
"categories": categories_flagged,
"message": "Este prompt foi assinalado pelo sistema de moderação."
}
return {"allowed": True}
def generate_safe_image(prompt: str, output: str):
"""Pipeline completo: moderação + geração."""
# Passo 1: pré-filtragem
check = verify_prompt(prompt)
if not check["allowed"]:
print(f"Prompt recusado: {check['message']}")
print(f"Categorias: {check['categories']}")
return None
# Passo 2: geração
print("Prompt validado, a gerar...")
return generate_with_moderation(prompt, output)
# Teste com um prompt inofensivo
generate_safe_image(
"A mountain landscape with a crystal clear lake",
"mountain.png"
)
Verifique Também as Imagens Geradas
Um prompt inocente pode resultar numa imagem que não o é. Uma formulação indireta, a ambiguidade de um termo ou simplesmente uma interpretação infeliz do modelo bastam para produzir conteúdo visual que não gostaria de ver exibido sob o seu logótipo. O modelo omni-moderation-latest aceita imagens como entrada, permitindo-lhe fechar o ciclo: a mesma mecânica de categorias aplica-se ao ficheiro gerado. O pipeline completo abaixo encadeia as três fases — verificação do prompt, geração, verificação da imagem — e, crucialmente, em caso de assinalamento, apaga o ficheiro do disco antes de devolver o seu veredicto. Uma imagem problemática deixada no servidor «enquanto verificamos» é uma imagem que acabará por vazar.
from openai import OpenAI
import base64
client = OpenAI()
def moderate_generated_image(image_path: str) -> dict:
"""Analisa uma imagem gerada para detetar conteúdo problemático."""
with open(image_path, "rb") as f:
image_b64 = base64.b64encode(f.read()).decode()
moderation = client.moderations.create(
model="omni-moderation-latest",
input=[
{
"type": "image_url",
"image_url": {
"url": f"data:image/png;base64,{image_b64}"
}
}
]
)
result = moderation.results[0]
if result.flagged:
categories_flagged = [
cat for cat, flagged in result.categories.__dict__.items()
if flagged
]
return {
"safe": False,
"categories": categories_flagged
}
return {"safe": True}
def secure_pipeline(prompt: str, output: str):
"""Pipeline completo: moderação do prompt + geração + moderação da imagem."""
# 1. Verificar o prompt
check_prompt = verify_prompt(prompt)
if not check_prompt["allowed"]:
return {"status": "prompt_refused", "details": check_prompt}
# 2. Gerar a imagem
response = client.images.generate(
model="gpt-image-2.5-sunburst",
prompt=prompt,
size="1024x1024",
quality="medium",
)
data = base64.b64decode(response.data[0].b64_json)
with open(output, "wb") as f:
f.write(data)
# 3. Verificar a imagem gerada
check_image = moderate_generated_image(output)
if not check_image["safe"]:
import os
os.remove(output)
return {
"status": "image_deleted",
"reason": "Imagem gerada foi assinalada",
"categories": check_image["categories"]
}
return {"status": "ok", "path": output}
Quando os Utilizadores Escrevem os Prompts
O conteúdo gerado pelo utilizador altera a natureza do problema: já não enfrenta apenas desajeitamento, mas, por vezes, tentativas deliberadas de contornar as regras. A classe PromptModerator empilha quatro defesas de naturezas diferentes, que é o próprio princípio de uma proteção séria. A limpeza remove caracteres de controlo através dos quais transitam injeções e limita o comprimento a quinhentos caracteres, cortando pela raiz prompts de inundação concebidos para afogar instruções. A verificação local via uma lista de palavras proibidas — deixada vazia, para ser preenchida de acordo com a sua política e setor — interceta a custo zero o que já conhece. A API de Moderação assume então tudo o que a sua lista não previu. Finalmente, o prefixo de segurança concatenado antes do prompt final lembra explicitamente ao modelo o enquadramento esperado, deslocando a fronteira a seu favor nos casos limite.
from openai import OpenAI
import re
client = OpenAI()
class PromptModerator:
"""Filtro multicamada para prompts de utilizadores."""
def __init__(self):
self.forbidden_words = [] # Preencha de acordo com a sua política
self.security_prefix = (
"Safe and appropriate image for all audiences. "
"No violent, sexual, or discriminatory content. "
)
def clean(self, prompt: str) -> str:
"""Limpa e normaliza um prompt de utilizador."""
# Remover potenciais injeções
prompt = prompt.strip()
# Limitar o comprimento
prompt = prompt[:500]
# Remover caracteres de controlo
prompt = re.sub(r'[\x00-\x1f\x7f-\x9f]', '', prompt)
return prompt
def check_words(self, prompt: str) -> bool:
"""Verifica a ausência de palavras proibidas."""
prompt_lower = prompt.lower()
for word in self.forbidden_words:
if word in prompt_lower:
return False
return True
def secure(self, prompt: str) -> str:
"""Adiciona um prefixo de segurança ao prompt."""
return f"{self.security_prefix}{prompt}"
def pipeline(self, raw_prompt: str) -> dict:
"""Pipeline completo de moderação para um prompt de utilizador."""
# Passo 1: limpeza
prompt = self.clean(raw_prompt)
# Passo 2: verificação local
if not self.check_words(prompt):
return {"allowed": False, "reason": "Palavra proibida detetada"}
# Passo 3: moderação via API
check = verify_prompt(prompt)
if not check["allowed"]:
return {"allowed": False, "reason": check["message"]}
# Passo 4: adicionar prefixo de segurança
final_prompt = self.secure(prompt)
return {"allowed": True, "prompt": final_prompt}
moderator = PromptModerator()
# Simular um prompt de utilizador
result = moderator.pipeline("A tabby cat sleeping on a red cushion")
if result["allowed"]:
print(f"Prompt seguro: {result['prompt']}")
else:
print(f"Recusado: {result['reason']}")
Registos para Responsabilização
No dia em que uma imagem problemática ressurgir, a pergunta que lhe farão será: quem a pediu, quando e o que fez o seu sistema. Sem registos, não tem resposta. O AuditLogger escreve uma linha JSON por geração num ficheiro .jsonl — um formato apenas de anexação que suporta escrita concorrente e pode ser lido linha a linha sem carregar tudo na memória. Cada entrada liga um ID de utilizador a um prompt truncado, ao resultado da geração e, se aplicável, ao motivo da recusa. O método report deriva então a taxa de aceitação nas últimas cem gerações e detalha as recusas: este é o painel que o alertará se uma conta específica acumular assinalamentos.
import json
import os
from datetime import datetime
class AuditLogger:
"""Registo de auditoria para gerações de imagens."""
def __init__(self, log_file: str = "audit_images.jsonl"):
self.log_file = log_file
def log(
self,
prompt: str,
user_id: str,
result: str,
image_path: str = None,
refusal_reason: str = None
):
"""Regista uma entrada de auditoria."""
entry = {
"timestamp": datetime.now().isoformat(),
"user_id": user_id,
"prompt": prompt[:200],
"result": result, # "ok", "prompt_refused", "image_deleted"
"image_path": image_path,
"refusal_reason": refusal_reason,
}
with open(self.log_file, "a") as f:
f.write(json.dumps(entry, ensure_ascii=False) + "\n")
def report(self, last_n: int = 100):
"""Gera um relatório das gerações recentes."""
if not os.path.exists(self.log_file):
print("Nenhum registo encontrado.")
return
entries = []
with open(self.log_file, "r") as f:
for line in f:
entries.append(json.loads(line))
recent = entries[-last_n:]
total = len(recent)
ok = sum(1 for e in recent if e["result"] == "ok")
refused = sum(1 for e in recent if e["result"] != "ok")
print(f"Relatório das últimas {total} gerações:")
print(f" Aceites: {ok} ({100*ok/total:.1f}%)")
print(f" Recusados : {refused} ({100*refused/total:.1f}%)")
if refused > 0:
print(f"\nDetalhes das recusas:")
for e in recent:
if e["result"] != "ok":
print(f" [{e['timestamp'][:10]}] {e['user_id']} : {e['refusal_reason']}")
logger = AuditLogger()
logger.report()
Direitos de Autor e Marcas Registadas
O GPT Image sabe produzir imagens que evocam o estilo de um artista ou a identidade visual de uma marca, e é exatamente esta capacidade que o expõe. A moderação técnica não o protege neste terreno: não deteta que um cartaz se assemelha muito ao de um concorrente. A proteção é, portanto, contratual e organizacional, sob a forma de uma política de utilização escrita e executável que os seus utilizadores aceitam e a sua equipa aplica. O bloco PRODUCTION_RULES dá a formulação mínima, a exibir na sua documentação bem como a recordar nos seus termos.
# Melhores práticas a integrar na sua política de utilização
PRODUCTION_RULES = """
1. Não solicite a imitação do estilo de um artista vivo pelo nome
2. Não reproduza logótipos ou marcas registadas
3. Não gere rostos de pessoas reais
4. Adicione um aviso «imagem gerada por IA» quando necessário
5. Mantenha os registos de geração por pelo menos 12 meses
6. Permita que os utilizadores reportem conteúdo problemático
"""
def usage_warning():
"""Exibe as regras de utilização em produção."""
print("=" * 60)
print("REGRAS DE PRODUÇÃO — Geração de Imagens por IA")
print("=" * 60)
print(PRODUCTION_RULES)
Conformidade com o RGPD
Para uma empresa europeia, os prazos de retenção e o consentimento não são opções de configuração, mas obrigações cujo cumprimento deve ser demonstrável. Registá-los num objeto de configuração explícito, em vez de os dispersar pelo código, dá-lhe um único local para mostrar durante uma auditoria. O ComplianceConfig define assim a retenção de registos para um ano, a retenção de imagens para noventa dias e torna obrigatório o aviso de IA e o consentimento. O método add_ai_metadata merece atenção especial: escreve no próprio PNG, via PngInfo, o facto de a imagem ser gerada, a ferramenta que a produziu e a data. Estes metadados viajam com o ficheiro, inclusive fora da sua plataforma, o que nenhum aviso exibido numa página web faz.
class ComplianceConfig:
"""Configuração de conformidade para geração de imagens."""
def __init__(self):
self.log_retention_days = 365
self.image_retention_days = 90
self.ai_notice_mandatory = True
self.consent_required = True
def verify_consent(self, user_id: str) -> bool:
"""Verifica se o utilizador consentiu a geração por IA."""
# Implementar com o seu sistema de gestão de consentimento
return True
def add_ai_metadata(self, image_path: str):
"""Adiciona metadados indicando geração por IA."""
from PIL import Image
from PIL.PngImagePlugin import PngInfo
img = Image.open(image_path)
metadata = PngInfo()
metadata.add_text("AI-Generated", "true")
metadata.add_text("Generator", "GPT Image via OpenAI API")
metadata.add_text("Date", datetime.now().isoformat())
img.save(image_path, pnginfo=metadata)
print(f"Metadados de IA adicionados: {image_path}")
Antes de Abrir as Comportas
Oito disposições devem estar no lugar no dia em que o seu sistema se tornar acessível, e é mais honesto pedi-las antes do que depois. Moderação primeiro, nas suas duas fases: pré-filtragem de prompts e pós-verificação de imagens, como faz o secure_pipeline. Registos a seguir, completos, associando cada geração ao seu prompt, autor e resultado — esta é a sua única prova em caso de disputa, e deve ser guardada independentemente das próprias imagens, caso contrário uma purga de armazenamento levaria consigo a sua rastreabilidade.
Depois vem o lado do utilizador. Um limite de taxa por conta impede que um único subscritor consuma o seu orçamento mensal numa noite, voluntariamente ou via um script mal escrito. A informação sobre a natureza gerada das imagens relaciona-se tanto com a equidade como, cada vez mais, com constrangimentos regulamentares; é duplicada por marcação técnica nos metadados PNG ou EXIF do ficheiro. O direito ao apagamento pressupõe que consiga encontrar e apagar todos os dados de um utilizador mediante simples pedido, o que só é possível se as suas entradas de auditoria transportarem um user_id. Finalmente, abra um canal de reporte: os seus utilizadores verão sempre o que é problemático antes de si, e retirar-lhes os meios de lho dizer não faz o problema desaparecer.
Agora assemble o todo num único serviço de geração de imagens: pré-filtragem de prompts via API de Moderação e lista de palavras, prefixo de segurança, pós-verificação da imagem produzida, registo de auditoria e metadados de IA em cada ficheiro. Teste-o com cinco prompts variados, pelo menos um dos quais deve ser recusado — esta é a única forma de verificar se as suas guardas-rail funcionam realmente e não estão apenas presentes no código.
Teste os Seus Conhecimentos
Geração visual via API: valide os reflexos antes da produção.
1. O que permitem o inpainting e o outpainting?
Resposta: O inpainting modifica uma área específica de uma imagem existente (substituir, corrigir); o outpainting estende a imagem para além do seu enquadramento original — duas edições direcionadas sem regenerar tudo.
2. O que constitui um bom prompt visual avançado?
Resposta: Descreva o sujeito, a composição, a iluminação e a perspetiva — não apenas o tema: quanto mais o prompt enquadrar a cena como um diretor de fotografia, mais a imagem obedecerá.
3. Como trabalhar eficazmente por iterações?
Resposta: Comece com uma geração base e peça depois variações direcionadas (estilo, enquadramento, detalhe) em vez de reescrever o prompt do zero — mantenha o que funciona, ajuste apenas o desvio.
4. Que alavancas para otimizar os custos de geração?
Resposta: Adapte a qualidade e a resolução à necessidade real (rascunhos em baixo, finais em alto), limite as iterações com melhores prompts e coloque em cache/reutilize visuais validados.
5. Porque é essencial a moderação de conteúdo visual?
Resposta: Porque a API e os seus termos impõem limites (conteúdo proibido, pessoas reais, marcas): filtrar prompts e controlar saídas protege os seus utilizadores e a sua aplicação.
Enquadre, itere, domine custos e conformidade: a produção visual é um pipeline — não um lance de dados.