Moderazione e sicurezza dei contenuti visivi
In questa pagina
- Moderazione e sicurezza dei contenuti visivi
- Il sistema di moderazione integrato
- Pre-filtraggio dei prompt
- Controlla anche le immagini generate
- Quando gli utenti scrivono i prompt
- Log per la responsabilità
- Copyright e marchi registrati
- Conformità al GDPR
- Prima di aprire le cateratte
- Metti alla prova le tue conoscenze
Aggiornato il 3 novembre 2026 sulla base della guida Image generation di OpenAI: un rifiuto per moderazione è identificato da
error.code == "moderation_blocked", con un oggetto opzionalemoderation_details, non dalla presenza delle parolesafetyocontent_policynel messaggio di errore; aggiunto il parametromoderation(auto,low). Fonte: Image generation.
Aggiornamento del 2 novembre 2026 — Modelli immagine.
gpt-image-1, su cui era originariamente scritto questo corso, è stato dismesso il 23 ottobre 2026, egpt-image-1.5,gpt-image-1-miniechatgpt-image-latestverranno ritirati il 1° dicembre 2026. Gli esempi ora usanogpt-image-2.5-sunburst, il più preciso per l’editing;gpt-image-2.5-flareè più veloce per la generazione standard. Entrambi accettano anche le qualitàxhighemax. I modelli GPT Image restituiscono sempre l’immagine in base64: il parametroresponse_formatdei vecchi modelli DALL·E non è accettato ed è stato rimosso dal codice. Fonte: Image generation (OpenAI).
Moderazione e sicurezza dei contenuti visivi
Finché generi immagini per te stesso, la moderazione è una questione di giudizio personale. Una volta che apri la generazione agli utenti, diventa una responsabilità legale ed etica che ti vincola. Questa lezione copre gli strumenti di moderazione di OpenAI, come concatenarli in filtri successivi e le misure che proteggono sia la tua applicazione sia le persone che la usano.
Il sistema di moderazione integrato
GPT Image rifiuta autonomamente certi contenuti—violenza, materiale sessualmente esplicito, tra gli altri—e segnala questo rifiuto con un errore specifico. Il tuo codice deve quindi distinguere un rifiuto per policy sui contenuti da un guasto tecnico, perché i due richiedono reazioni opposte: il primo si traduce in un messaggio all’utente, il secondo in un allerta al tuo team. La documentazione di OpenAI specifica il discriminante da usare: un rifiuto per moderazione arriva come BadRequestError con error.code uguale a moderation_blocked (tipo image_generation_user_error), e il corpo dell’errore può contenere un oggetto moderation_details che specifica la fase (input, output o unknown) e le categorie generali (harassment, sexual, violence…). Non cercare parole nel messaggio di errore: il suo testo non è un contratto, lo è il codice. La funzione seguente rilancia l’eccezione solo se non si tratta di un rifiuto per moderazione.
from openai import OpenAI, BadRequestError
client = OpenAI()
def generate_with_moderation(prompt: str, output: str) -> dict:
"""Genera un'immagine gestendo i rifiuti per moderazione."""
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 # guasto tecnico, quota, richiesta non valida: gestire altrove
body = e.body if isinstance(e.body, dict) else {}
details = body.get("moderation_details") or {}
return {
"status": "refused",
"reason": "Contenuto rifiutato dalla policy di sicurezza",
"stage": details.get("moderation_stage"), # input, output o unknown
"categories": details.get("categories") or [], # per i tuoi log
}
result = generate_with_moderation(
"A kitten playing with a ball of yarn",
"kitten.png"
)
print(result)
OpenAI consiglia di mantenere un messaggio generico per l’utente finale e di riservare moderation_details ai tuoi log e al supporto. Questi errori non si risolvono ritentando: senza modificare il prompt o le immagini fornite, la stessa richiesta verrà rifiutata di nuovo. Nota infine che la severità del filtraggio è impostata dal parametro moderation dei modelli GPT Image: auto (filtraggio standard, default) o low (meno restrittivo).
Pre-filtraggio dei prompt
Aspettare che GPT Image rifiuti un prompt prima di scoprire che era problematico è insoddisfacente: hai già consumato la chiamata API e non impari nulla di specifico sul motivo. L’API di Moderazione, invece, è gratuita, veloce e restituisce categorie nominate. Chiamarla prima della generazione ti permette di rifiutare in modo pulito, spiegare all’utente cosa è stato segnalato e conservare questa informazione per il tuo audit. La funzione verify_prompt estrae l’elenco delle categorie attivate, e generate_safe_image concatena semplicemente i due passaggi: controlla prima, genera dopo.
from openai import OpenAI
client = OpenAI()
def verify_prompt(prompt: str) -> dict:
"""Controlla un prompt con l'API di Moderazione prima della generazione."""
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": "Questo prompt è stato segnalato dal sistema di moderazione."
}
return {"allowed": True}
def generate_safe_image(prompt: str, output: str):
"""Pipeline completa: moderazione + generazione."""
# Passo 1: pre-filtraggio
check = verify_prompt(prompt)
if not check["allowed"]:
print(f"Prompt rifiutato: {check['message']}")
print(f"Categorie: {check['categories']}")
return None
# Passo 2: generazione
print("Prompt validato, generazione in corso...")
return generate_with_moderation(prompt, output)
# Test con un prompt innocuo
generate_safe_image(
"A mountain landscape with a crystal clear lake",
"mountain.png"
)
Controlla anche le immagini generate
Un prompt innocente può produrre un’immagine che non lo è. Una formulazione indiretta, l’ambiguità di un termine o semplicemente un’interpretazione sfortunata del modello bastano a produrre contenuti visivi che non vorresti vedere sotto il tuo logo. Il modello omni-moderation-latest accetta immagini come input, permettendoti di chiudere il cerchio: le stesse meccaniche di categoria si applicano al file generato. La pipeline completa qui sotto concatena le tre fasi—controllo del prompt, generazione, controllo dell’immagine—e, cosa cruciale, in caso di segnalazione, cancella il file dal disco prima di restituire il verdetto. Un’immagine problematica lasciata sul server “mentre diamo un’occhiata” è un’immagine che prima o poi trapelerà.
from openai import OpenAI
import base64
client = OpenAI()
def moderate_generated_image(image_path: str) -> dict:
"""Analizza un'immagine generata per rilevare contenuti problematici."""
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 completa: moderazione prompt + generazione + moderazione immagine."""
# 1. Controlla il prompt
check_prompt = verify_prompt(prompt)
if not check_prompt["allowed"]:
return {"status": "prompt_refused", "details": check_prompt}
# 2. Genera l'immagine
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. Controlla l'immagine generata
check_image = moderate_generated_image(output)
if not check_image["safe"]:
import os
os.remove(output)
return {
"status": "image_deleted",
"reason": "L'immagine generata è stata segnalata",
"categories": check_image["categories"]
}
return {"status": "ok", "path": output}
Quando gli utenti scrivono i prompt
I contenuti generati dagli utenti cambiano la natura del problema: non ti trovi più di fronte a goffaggini ma, a volte, a tentativi deliberati di elusione. La classe PromptModerator sovrappone quattro difese di natura diversa, che è il principio stesso di una protezione seria. La pulizia rimuove i caratteri di controllo attraverso i quali transitano le iniezioni e limita la lunghezza a cinquecento caratteri, tagliando corto sui prompt a diluvio progettati per sommergere le istruzioni. La verifica locale tramite una lista di parole vietate—lasciata vuota, da riempire in base alla tua policy e al tuo settore—intercetta a costo zero ciò che già conosci. L’API di Moderazione subentra poi per tutto ciò che la tua lista non ha previsto. Infine, il prefisso di sicurezza concatenato prima del prompt finale ricorda esplicitamente al modello il quadro atteso, spostando il confine a tuo favore nei casi limite.
from openai import OpenAI
import re
client = OpenAI()
class PromptModerator:
"""Filtro multilivello per i prompt degli utenti."""
def __init__(self):
self.forbidden_words = [] # Da riempire in base alla tua policy
self.security_prefix = (
"Safe and appropriate image for all audiences. "
"No violent, sexual, or discriminatory content. "
)
def clean(self, prompt: str) -> str:
"""Pulisce e normalizza un prompt dell'utente."""
# Rimuovi potenziali iniezioni
prompt = prompt.strip()
# Limita la lunghezza
prompt = prompt[:500]
# Rimuovi i caratteri di controllo
prompt = re.sub(r'[\x00-\x1f\x7f-\x9f]', '', prompt)
return prompt
def check_words(self, prompt: str) -> bool:
"""Controlla l'assenza di parole vietate."""
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:
"""Aggiunge un prefisso di sicurezza al prompt."""
return f"{self.security_prefix}{prompt}"
def pipeline(self, raw_prompt: str) -> dict:
"""Pipeline completa di moderazione per un prompt utente."""
# Passo 1: pulizia
prompt = self.clean(raw_prompt)
# Passo 2: verifica locale
if not self.check_words(prompt):
return {"allowed": False, "reason": "Parola vietata rilevata"}
# Passo 3: moderazione API
check = verify_prompt(prompt)
if not check["allowed"]:
return {"allowed": False, "reason": check["message"]}
# Passo 4: aggiungi prefisso di sicurezza
final_prompt = self.secure(prompt)
return {"allowed": True, "prompt": final_prompt}
moderator = PromptModerator()
# Simula un prompt utente
result = moderator.pipeline("A tabby cat sleeping on a red cushion")
if result["allowed"]:
print(f"Prompt sicuro: {result['prompt']}")
else:
print(f"Rifiutato: {result['reason']}")
Log per la responsabilità
Il giorno in cui un’immagine problematica riemerge, la domanda che ti verrà posta è: chi l’ha richiesta, quando e cosa ha fatto il tuo sistema. Senza log, non hai risposta. AuditLogger scrive una riga JSON per generazione in un file .jsonl—un formato append-only che supporta la scrittura concorrente e può essere letto riga per riga senza caricare tutto in memoria. Ogni voce collega un ID utente a un prompt troncato, all’esito della generazione e, se applicabile, al motivo del rifiuto. Il metodo report deriva quindi il tasso di accettazione sulle ultime cento generazioni e dettaglia i rifiuti: questa è la dashboard che ti avviserà se un account particolare accumula segnalazioni.
import json
import os
from datetime import datetime
class AuditLogger:
"""Log di audit per le generazioni di immagini."""
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
):
"""Registra una voce di audit."""
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):
"""Genera un report delle generazioni recenti."""
if not os.path.exists(self.log_file):
print("Nessun log trovato.")
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"Report delle ultime {total} generazioni:")
print(f" Accettate: {ok} ({100*ok/total:.1f}%)")
print(f" Rifiutate : {refused} ({100*refused/total:.1f}%)")
if refused > 0:
print(f"\nDettagli sui rifiuti:")
for e in recent:
if e["result"] != "ok":
print(f" [{e['timestamp'][:10]}] {e['user_id']} : {e['refusal_reason']}")
logger = AuditLogger()
logger.report()
Copyright e marchi registrati
GPT Image sa produrre immagini che evocano lo stile di un artista o l’identità visiva di un brand, ed è proprio questa capacità a esporti. La moderazione tecnica non ti protegge su questo terreno: non rileva che un poster assomiglia moltissimo a quello di un concorrente. La protezione è quindi contrattuale e organizzativa, sotto forma di una policy d’uso scritta e applicabile che i tuoi utenti accettano e il tuo team applica. Il blocco PRODUCTION_RULES fornisce la formulazione minima, da mostrare nella tua documentazione così come da richiamare nei tuoi termini.
# Best practice da integrare nella tua policy d'uso
PRODUCTION_RULES = """
1. Non richiedere l'imitazione dello stile di un artista vivente per nome
2. Non riprodurre loghi o marchi registrati
3. Non generare volti di persone reali
4. Aggiungere un avviso "Immagine generata da AI" quando richiesto
5. Conservare i log di generazione per almeno 12 mesi
6. Consentire agli utenti di segnalare contenuti problematici
"""
def usage_warning():
"""Mostra le regole d'uso per la produzione."""
print("=" * 60)
print("REGOLE DI PRODUZIONE — Generazione di immagini AI")
print("=" * 60)
print(PRODUCTION_RULES)
Conformità al GDPR
Per un’azienda europea, i periodi di conservazione e il consenso non sono opzioni di configurazione ma obblighi il cui rispetto deve essere dimostrabile. Registrarli in un oggetto di configurazione esplicito, invece di spargerli nel codice, ti dà un unico posto da mostrare durante un audit. ComplianceConfig imposta quindi la conservazione dei log a un anno, quella delle immagini a novanta giorni e rende obbligatori l’avviso AI e il consenso. Il metodo add_ai_metadata merita particolare attenzione: scrive nel PNG stesso, tramite PngInfo, il fatto che l’immagine è generata, lo strumento che l’ha prodotta e la data. Questi metadati viaggiano con il file, anche fuori dalla tua piattaforma, cosa che nessun avviso visualizzato su una pagina web fa.
class ComplianceConfig:
"""Configurazione di conformità per la generazione di immagini."""
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 che l'utente abbia acconsentito alla generazione AI."""
# Implementare con il proprio sistema di gestione del consenso
return True
def add_ai_metadata(self, image_path: str):
"""Aggiunge metadati che indicano la generazione AI."""
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"Metadati AI aggiunti: {image_path}")
Prima di aprire le cateratte
Otto disposizioni devono essere in atto il giorno in cui il tuo sistema diventa accessibile, ed è più onesto chiederle prima piuttosto che dopo. Moderazione prima, nelle sue due fasi: pre-filtraggio dei prompt e post-verifica delle immagini, come fa secure_pipeline. Log dopo, completi, che associano ogni generazione al suo prompt, autore ed esito—questa è la tua unica prova in caso di controversia, e deve essere salvata indipendentemente dalle immagini stesse, altrimenti una pulizia dello storage porterebbe via anche la tua tracciabilità.
Poi viene il lato utente. Un rate limit per account impedisce a un singolo abbonato di consumare il tuo budget mensile in una notte, volontariamente o tramite uno script scritto male. L’informazione sulla natura generata delle immagini riguarda sia l’equità sia, sempre più, un vincolo normativo; è raddoppiata dalla marcatura tecnica nei metadati PNG o EXIF del file. Il diritto alla cancellazione presuppone che tu possa trovare ed eliminare tutti i dati di un utente su semplice richiesta, cosa possibile solo se le tue voci di audit portano un user_id. Infine, apri un canale di segnalazione: i tuoi utenti vedranno sempre ciò che è problematico prima di te, e togliere loro i mezzi per dirtelo non fa scomparire il problema.
Ora assembla il tutto in un unico servizio di generazione immagini: pre-filtraggio dei prompt tramite API di Moderazione e lista di parole, prefisso di sicurezza, post-verifica dell’immagine prodotta, log di audit e metadati AI su ogni file. Testalo con cinque prompt vari, almeno uno dei quali deve essere rifiutato—questo è l’unico modo per verificare che le tue guardrail funzionino davvero invece di essere solo presenti nel codice.
Metti alla prova le tue conoscenze
Generazione visiva via API: valida i riflessi prima della produzione.
1. Cosa permettono inpainting e outpainting?
Risposta: L’inpainting modifica un’area specifica di un’immagine esistente (sostituisce, corregge); l’outpainting estende l’immagine oltre la sua cornice originale—due modifiche mirate senza rigenerare tutto.
2. Cosa rende buono un prompt visivo avanzato?
Risposta: Descrivi soggetto, composizione, illuminazione e prospettiva—non solo il tema: più il prompt inquadra la scena come un direttore della fotografia, più l’immagine obbedisce.
3. Come lavorare efficacemente per iterazioni?
Risposta: Inizia con una generazione di base, poi richiedi variazioni mirate (stile, inquadratura, dettaglio) invece di riscrivere il prompt da zero—mantieni ciò che funziona, modifica solo il divario.
4. Quali leve per ottimizzare i costi di generazione?
Risposta: Adatta qualità e risoluzione al bisogno reale (bozze in low, finali in high), limita le iterazioni con prompt migliori e cached/riutilizza i visual validati.
5. Perché la moderazione dei contenuti visivi è essenziale?
Risposta: Perché l’API e i tuoi termini impongono limiti (contenuti vietati, persone reali, brand): filtrare i prompt e controllare gli output protegge i tuoi utenti e la tua applicazione.
Inquadra, itera, padroneggia costi e conformità: la produzione visiva è una pipeline, non un lancio di dadi.