Moderare și siguranța conținutului vizual
Pe această pagină
- Moderare și siguranța conținutului vizual
- Sistemul integrat de moderare
- Prefiltrarea prompturilor
- Verificați și imaginile generate
- Când utilizatorii scriu prompturile
- Jurnalizare pentru responsabilitate
- Drepturi de autor și mărci comerciale
- Conformitatea cu GDPR
- Înainte de a deschide ecluzele
- Testați-vă cunoștințele
Actualizat la 3 noiembrie 2026 pe baza ghidului Generare de imagini de la OpenAI: Un refuz de moderare este identificat prin
error.code == "moderation_blocked", cu un obiect opționalmoderation_details, nu prin prezența cuvintelorsafetysaucontent_policyîn mesajul de eroare; a fost adăugat parametrulmoderation(auto,low). Sursă: Generare de imagini.
Actualizare 2 noiembrie 2026 — Modele de imagini.
gpt-image-1, pe care s-a bazat inițial acest curs, a fost întrerupt la 23 octombrie 2026, iargpt-image-1.5,gpt-image-1-minișichatgpt-image-latestvor fi retrase la 1 decembrie 2026. Exemplele folosesc acumgpt-image-2.5-sunburst, cel mai precis pentru editare;gpt-image-2.5-flareeste mai rapid pentru generarea standard. Ambele acceptă, de asemenea, calitățilexhighșimax. Modelele GPT Image returnează întotdeauna imaginea în base64: parametrulresponse_formatde la modelele DALL·E mai vechi nu este acceptat și a fost eliminat din cod. Sursă: Generare de imagini (OpenAI).
Moderare și siguranța conținutului vizual
Atâta timp cât generați imagini pentru dumneavoastră înșivă, moderarea este o chestiune de judecată personală. Odată ce deschideți generarea către utilizatori, aceasta devine o responsabilitate legală și etică care vă angajează. Această lecție acoperă instrumentele de moderare ale OpenAI, modul de a le înlănțui în filtre succesive și măsurile care vă protejează atât aplicația, cât și persoanele care o utilizează.
Sistemul integrat de moderare
GPT Image refuză singur anumite conținuturi—violență, materiale cu caracter sexual explicit, printre altele—și semnalează acest refuz printr-o eroare specifică. Codul dumneavoastră trebuie, prin urmare, să distingă un refuz bazat pe politica de conținut de o defecțiune tehnică, deoarece cele două necesită reacții opuse: primul rezultă într-un mesaj către utilizator, al doilea într-o alertă către echipa dumneavoastră. Documentația OpenAI specifică discriminatorul de utilizat: un refuz de moderare sosește sub forma unei BadRequestError cu error.code egal cu moderation_blocked (tip image_generation_user_error), iar corpul erorii poate conține un obiect moderation_details care specifică etapa (input, output sau unknown) și categoriile generale (harassment, sexual, violence…). Nu căutați cuvinte în mesajul de eroare: textul său nu este un contract, codul este. Funcția de mai jos re-aruncă excepția doar dacă nu este un refuz de moderare.
from openai import OpenAI, BadRequestError
client = OpenAI()
def generate_with_moderation(prompt: str, output: str) -> dict:
"""Generează o imagine gestionând refuzurile de moderare."""
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 # defecțiune tehnică, cotă, cerere invalidă: gestionați elsewhere
body = e.body if isinstance(e.body, dict) else {}
details = body.get("moderation_details") or {}
return {
"status": "refused",
"reason": "Conținut refuzat de politica de siguranță",
"stage": details.get("moderation_stage"), # input, output sau unknown
"categories": details.get("categories") or [], # pentru jurnalele dumneavoastră
}
result = generate_with_moderation(
"A kitten playing with a ball of yarn",
"kitten.png"
)
print(result)
OpenAI sfătuiește să păstrați un mesaj generic pentru utilizatorul final și să rezervați moderation_details pentru jurnalele și suportul dumneavoastră. Aceste erori nu se rezolvă prin reîncercare: fără modificarea promptului sau a imaginilor furnizate, aceeași cerere va fi refuzată din nou. Rețineți, în final, că severitatea filtrării este stabilită de parametrul moderation al modelelor GPT Image: auto (filtrare standard, implicit) sau low (mai puțin restrictiv).
Prefiltrarea prompturilor
Așteptarea ca GPT Image să refuze un prompt înainte de a descoperi că era problematic este nesatisfăcătoare: ați consumat deja apelul API și nu aflați nimic specific despre motiv. API-ul de Moderare, totuși, este gratuit, rapid și returnează categorii numite. Apelarea acestuia înainte de generare vă permite să refuzați corect, să explicați utilizatorului ce a fost semnalat și să păstrați aceste informații pentru auditul dumneavoastră. Funcția verify_prompt extrage lista categoriilor declanșate, iar generate_safe_image înlănțuie pur și simplu cei doi pași: verifică mai întâi, generează al doilea.
from openai import OpenAI
client = OpenAI()
def verify_prompt(prompt: str) -> dict:
"""Verifică un prompt cu API-ul de Moderare înainte de generare."""
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": "Acest prompt a fost semnalat de sistemul de moderare."
}
return {"allowed": True}
def generate_safe_image(prompt: str, output: str):
"""Flux complet: moderare + generare."""
# Pasul 1: prefiltrare
check = verify_prompt(prompt)
if not check["allowed"]:
print(f"Prompt refuzat: {check['message']}")
print(f"Categorii: {check['categories']}")
return None
# Pasul 2: generare
print("Prompt validat, se generează...")
return generate_with_moderation(prompt, output)
# Test cu un prompt inofensiv
generate_safe_image(
"A mountain landscape with a crystal clear lake",
"mountain.png"
)
Verificați și imaginile generate
Un prompt inocent poate produce o imagine care nu este. O formulare ocolită, ambiguitatea unui termen sau pur și simplu o interpretare nefericită a modelului sunt suficiente pentru a produce conținut vizual pe care nu ați dori să-l vedeți afișat sub logo-ul dumneavoastră. Modelul omni-moderation-latest acceptă imagini ca intrare, permițându-vă să închideți bucla: aceleași mecanisme de categorie se aplică fișierului generat. Fluxul complet de mai jos înlănțuie cele trei faze—verificarea promptului, generarea, verificarea imaginii—și, crucial, în cazul unei semnalări, șterge fișierul de pe disc înainte de a returna verdictul său. O imagine problematică lăsată pe server „în timp ce verificăm“ este o imagine care va scăpa inevitabil.
from openai import OpenAI
import base64
client = OpenAI()
def moderate_generated_image(image_path: str) -> dict:
"""Analizează o imagine generată pentru a detecta conținut problematic."""
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):
"""Flux complet: moderare prompt + generare + moderare imagine."""
# 1. Verifică promptul
check_prompt = verify_prompt(prompt)
if not check_prompt["allowed"]:
return {"status": "prompt_refused", "details": check_prompt}
# 2. Generează imaginea
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. Verifică imaginea generată
check_image = moderate_generated_image(output)
if not check_image["safe"]:
import os
os.remove(output)
return {
"status": "image_deleted",
"reason": "Imaginea generată a fost semnalată",
"categories": check_image["categories"]
}
return {"status": "ok", "path": output}
Când utilizatorii scriu prompturile
Conținutul generat de utilizatori schimbă natura problemei: nu mai aveți de-a face cu stângăcii, ci, uneori, cu tentative deliberate de ocolire. Clasa PromptModerator stivruiește patru apărări de naturi diferite, ceea ce constituie chiar principiul unei protecții serioase. Curățarea elimină caracterele de control prin care tranzitează injecțiile și limitează lungimea la cinci sute de caractere, tăind scurt prompturile de tip inundație concepute să înec instrucțiunile. Verificarea locală printr-o listă de cuvinte interzise—lăsată goală, de completat în funcție de politica și sectorul dumneavoastră—interceptează pe cost zero ceea ce știți deja. API-ul de Moderare preia apoi totul ceea ce lista dumneavoastră nu a anticipat. În final, prefixul de securitate concatenat înainte de promptul final reamintește explicit modelului cadrul așteptat, deplasând limita în favoarea dumneavoastră pentru cazurile limită.
from openai import OpenAI
import re
client = OpenAI()
class PromptModerator:
"""Filtru multi-strat pentru prompturile utilizatorilor."""
def __init__(self):
self.forbidden_words = [] # Completați conform politicii dumneavoastră
self.security_prefix = (
"Imagine sigură și adecvată pentru toate publicurile. "
"Fără conținut violent, sexual sau discriminatoriu. "
)
def clean(self, prompt: str) -> str:
"""Curăță și normalizează un prompt al utilizatorului."""
# Elimină injecțiile potențiale
prompt = prompt.strip()
# Limitează lungimea
prompt = prompt[:500]
# Elimină caracterele de control
prompt = re.sub(r'[\x00-\x1f\x7f-\x9f]', '', prompt)
return prompt
def check_words(self, prompt: str) -> bool:
"""Verifică absența cuvintelor interzise."""
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:
"""Adaugă un prefix de securitate la prompt."""
return f"{self.security_prefix}{prompt}"
def pipeline(self, raw_prompt: str) -> dict:
"""Flux complet de moderare pentru un prompt al utilizatorului."""
# Pasul 1: curățare
prompt = self.clean(raw_prompt)
# Pasul 2: verificare locală
if not self.check_words(prompt):
return {"allowed": False, "reason": "Cuvânt interzis detectat"}
# Pasul 3: moderare API
check = verify_prompt(prompt)
if not check["allowed"]:
return {"allowed": False, "reason": check["message"]}
# Pasul 4: adaugă prefixul de securitate
final_prompt = self.secure(prompt)
return {"allowed": True, "prompt": final_prompt}
moderator = PromptModerator()
# Simulează un prompt al utilizatorului
result = moderator.pipeline("A tabby cat sleeping on a red cushion")
if result["allowed"]:
print(f"Prompt securizat: {result['prompt']}")
else:
print(f"Refuzat: {result['reason']}")
Jurnalizare pentru responsabilitate
În ziua în care o imagine problematică reapare, întrebarea care vi se va pune este: cine a solicitat-o, când și ce a făcut sistemul dumneavoastră. Fără jurnale, nu aveți niciun răspuns. AuditLogger scrie o linie JSON per generare într-un fișier .jsonl—un format doar pentru adăugare care suportă scrierea concurentă și poate fi citit linie cu linie fără a încărca totul în memorie. Fiecare intrare leagă un ID de utilizator de un prompt trunchiat, rezultatul generării și, dacă este cazul, motivul refuzului. Metoda report derivează apoi rata de acceptare pentru ultimele o sută de generări și detaliază refuzurile: acesta este tabloul de bord care vă va alerta dacă un anumit cont acumulează semnalări.
import json
import os
from datetime import datetime
class AuditLogger:
"""Jurnal de audit pentru generările de imagini."""
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
):
"""Înregistrează o intrare de 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):
"""Generează un raport al generărilor recente."""
if not os.path.exists(self.log_file):
print("Nu s-au găsit jurnale.")
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"Raport pentru ultimele {total} generări:")
print(f" Acceptate: {ok} ({100*ok/total:.1f}%)")
print(f" Refuzate : {refused} ({100*refused/total:.1f}%)")
if refused > 0:
print(f"\nDetalii refuz:")
for e in recent:
if e["result"] != "ok":
print(f" [{e['timestamp'][:10]}] {e['user_id']} : {e['refusal_reason']}")
logger = AuditLogger()
logger.report()
Drepturi de autor și mărci comerciale
GPT Image știe să producă imagini care evocă stilul unui artist sau identitatea vizuală a unui brand, iar această capacitate este exact ceea ce vă expune. Moderarea tehnică nu vă protejează pe acest teren: ea nu detectează că un afiș seamănă foarte mult cu cel al unui concurent. Protecția este, prin urmare, contractuală și organizațională, sub forma unei politici de utilizare scrise și aplicabile, pe care utilizatorii dumneavoastră o acceptă și echipa dumneavoastră o aplică. Blocul PRODUCTION_RULES oferă formularea minimă, de afișat în documentația dumneavoastră, precum și de reamintit în termenii dumneavoastră.
# Cele mai bune practici de integrat în politica dumneavoastră de utilizare
PRODUCTION_RULES = """
1. Nu solicitați imitarea stilului unui artist în viață pe nume
2. Nu reproduceți logo-uri sau mărci comerciale înregistrate
3. Nu generați fețe ale unor persoane reale
4. Adăugați o notificare „Imagine generată de AI“ atunci când este necesar
5. Păstrați jurnalele de generare timp de cel puțin 12 luni
6. Permiteți utilizatorilor să raporteze conținut problematic
"""
def usage_warning():
"""Afișează regulile de utilizare în producție."""
print("=" * 60)
print("REGULI DE PRODUCȚIE — Generare de imagini AI")
print("=" * 60)
print(PRODUCTION_RULES)
Conformitatea cu GDPR
Pentru o companie europeană, perioadele de retenție și consimțământul nu sunt opțiuni de configurare, ci obligații al căror respect trebuie demonstrabil. Înregistrarea lor într-un obiect de configurare explicit, în loc să fie împrăștiate prin cod, vă oferă un singur loc de arătat în timpul unui audit. ComplianceConfig stabilește astfel retenția jurnalelor la un an, retenția imaginilor la nouăzeci de zile și face obligatorie notificarea AI și consimțământul. Metoda add_ai_metadata merită o atenție specială: ea scrie în PNG-ul însuși, prin PngInfo, faptul că imaginea este generată, instrumentul care a produs-o și data. Aceste metadate călătoresc cu fișierul, inclusiv în afara platformei dumneavoastră, lucru pe care nicio notificare afișată pe o pagină web nu îl face.
class ComplianceConfig:
"""Configurare de conformitate pentru generarea de imagini."""
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:
"""Verifică dacă utilizatorul și-a dat consimțământul pentru generarea AI."""
# Implementați cu sistemul dumneavoastră de gestionare a consimțământului
return True
def add_ai_metadata(self, image_path: str):
"""Adaugă metadate indicând generarea 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"Metadate AI adăugate: {image_path}")
Înainte de a deschide ecluzele
Opt prevederi trebuie să fie în vigoare în ziua în care sistemul dumneavoastră devine accesibil, și este mai onest să le cereți înainte decât după. Moderarea mai întâi, în cele două faze ale sale: prefiltrarea prompturilor și post-verificarea imaginilor, așa cum face secure_pipeline. Jurnalizarea apoi, completă, asociind fiecare generare cu promptul său, autorul și rezultatul—aceasta este singura dumneavoastră dovadă în caz de litigiu și trebuie salvată independent de imaginile în sine, altfel o purjare a stocării ar lua cu ea și trasabilitatea dumneavoastră.
Apoi vine partea utilizatorului. O limită de rată per cont împiedică un singur abonat să consume bugetul dumneavoastră lunar într-o singură noapte, voluntar sau printr-un script scris prost. Informația despre natura generată a imaginilor se referă atât la echitate, cât și, din ce în ce mai mult, la constrângeri de reglementare; ea este dublată de marcarea tehnică în metadatele PNG sau EXIF ale fișierului. Dreptul la ștergere presupune că puteți găsi și șterge toate datele unui utilizator la simpla cerere, ceea ce este posibil doar dacă intrările dumneavoastră de audit poartă un user_id. În final, deschideți un canal de raportare: utilizatorii dumneavoastră vor vedea întotdeauna ce este problematic înainte ca dumneavoastră să o faceți, iar luarea mijloacelor lor de a vă spune nu face problema să dispară.
Acum asamblați totul într-un singur serviciu de generare de imagini: prefiltrarea prompturilor prin API-ul de Moderare și lista de cuvinte, prefixul de securitate, post-verificarea imaginii produse, jurnalul de audit și metadatele AI pe fiecare fișier. Testați-l cu cinci prompturi variate, dintre care cel puțin unul trebuie să fie refuzat—aceasta este singura modalitate de a verifica dacă gardurile dumneavoastră funcționează efectiv, nu doar că sunt prezente în cod.
Testați-vă cunoștințele
Generarea vizuală prin API: validați reflexele înainte de producție.
1. Ce permit inpainting și outpainting?
Răspuns: Inpainting modifică o zonă specifică a unei imagini existente (înlocuire, corectare); outpainting extinde imaginea dincolo de cadrul său original—două editări țintite fără a regenera totul.
2. Ce face un prompt vizual avansat bun?
Răspuns: Descrieți subiectul, compoziția, iluminarea și perspectiva—nu doar tema: cu cât promptul încadrează scena ca un director de imagine, cu atât imaginea se supune mai bine.
3. Cum să lucrați eficient prin iterații?
Răspuns: Începeți cu o generare de bază, apoi solicitați variații țintite (stil, încadrare, detaliu) în loc să rescrieți promptul de la zero—păstrați ce funcționează, ajustați doar diferența.
4. Ce pârghii pentru a optimiza costurile de generare?
Răspuns: Adaptați calitatea și rezoluția la nevoia reală (ciorne în low, finale în high), limitați iterațiile cu prompturi mai bune și stocați în cache/refolosiți vizualele validate.
5. De ce este esențială moderarea conținutului vizual?
Răspuns: Deoarece API-ul și termenii dumneavoastră impun limite (conținut interzis, persoane reale, branduri): filtrarea prompturilor și controlul ieșirilor vă protejează utilizatorii și aplicația.
Încadrați, iterați, stăpâniți costurile și conformitatea: producția vizuală este un flux—nu o aruncare la zaruri.