Moderācija un vizuālā satura drošība
Šajā lapā
Atjaunināts 2026. gada 3. novembrī, pamatojoties uz OpenAI Image generation rokasgrāmatu: Moderācijas atteikums tiek identificēts ar
error.code == "moderation_blocked"un opcionālumoderation_detailsobjektu, nevis pēc vārdusafetyvaicontent_policyklātbūtnes kļūdas ziņojumā; pievienotsmoderationparametrs (auto,low). Avots: Image generation.
2026. gada 2. novembra atjauninājums — attēlu modeļi.
gpt-image-1, uz kura sākotnēji bija balstīts šis kurss, tika pārtraukts 2026. gada 23. oktobrī, betgpt-image-1.5,gpt-image-1-miniunchatgpt-image-latesttiks izslēgti 2026. gada 1. decembrī. Piemēros tagad tiek izmantotsgpt-image-2.5-sunburst, kas ir visprecīzākais rediģēšanai;gpt-image-2.5-flareir ātrāks standarta ģenerēšanai. Abi pieņem arīxhighunmaxkvalitāti. GPT Image modeļi vienmēr atgriež attēlu base64 formātā: vecāku DALL·E modeļuresponse_formatparametrs netiek pieņemts un ir izņemts no koda. Avots: Image generation (OpenAI).
Moderācija un vizuālā satura drošība
Kamēr ģenerē attēlus tikai sev, moderācija ir personiskas izvēles jautājums. Tiklīdz ļauj ģenerēšanu lietotājiem, tā kļūst par juridisku un ētisku atbildību, kas tevi saista. Šī nodarbība aptver OpenAI moderācijas rīkus, to sasaistīšanu secīgos filtros un pasākumus, kas aizsargā gan tavu lietotni, gan cilvēkus, kas to lieto.
Iebūvētā moderācijas sistēma
GPT Image pats atsaka noteiktu saturu — vardarbību, seksuāli eksplicītus materiālus un citus — un signalizē par šo atteikumu ar specifisku kļūdu. Tavam kodam ir jānošķir satura politikas atteikums no tehniskas kļūmes, jo abas prasa pretējas reakcijas: pirmajā gadījumā lietotājam rādi ziņojumu, otrajā — brīdini savu komandu. OpenAI dokumentācija norāda discriminatoru: moderācijas atteikums pienāk kā BadRequestError, kur error.code ir vienāds ar moderation_blocked (tips image_generation_user_error), un kļūdas ķermenī var būt moderation_details objekts, kas precizē posmu (input, output vai unknown) un vispārīgās kategorijas (harassment, sexual, violence…). Nemeklē vārdus kļūdas ziņojumā: tā teksts nav līgums, kods ir. Tālāk esošā funkcija atkārtoti izraisa izņēmumu tikai tad, ja tas nav moderācijas atteikums.
from openai import OpenAI, BadRequestError
client = OpenAI()
def generate_with_moderation(prompt: str, output: str) -> dict:
"""Ģenerē attēlu, apstrādājot moderācijas atteikumus."""
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 # tehniska kļūme, kvota, nederīgs pieprasījums: apstrādā citur
body = e.body if isinstance(e.body, dict) else {}
details = body.get("moderation_details") or {}
return {
"status": "refused",
"reason": "Saturs atteikts saskaņā ar drošības politiku",
"stage": details.get("moderation_stage"), # input, output vai unknown
"categories": details.get("categories") or [], # taviem žurnāliem
}
result = generate_with_moderation(
"A kitten playing with a ball of yarn",
"kitten.png"
)
print(result)
OpenAI iesaka lietotājam rādīt vispārīgu ziņojumu, bet moderation_details paturēt saviem žurnāliem un atbalstam. Šīs kļūdas neatrisinās, atkārtojot mēģinājumu: nemainot uzvedni vai nodrošinātos attēlus, tas pats pieprasījums tiks atteikts atkal. Visbeidzot ņem vērā, ka filtrēšanas stingrību nosaka GPT Image modeļu moderation parametrs: auto (standarta filtrēšana, noklusējums) vai low (mazāk ierobežojoša).
Uzvedņu iepriekšēja filtrēšana
Gaidīt, kamēr GPT Image atsaka uzvedni, lai uzzinātu, ka tā bija problemātiska, ir neapmierinoši: jau esi iztērējis API izsaukumu un neuzzini neko konkrētu par iemeslu. Toties Moderācijas API ir bezmaksas, ātra un atgriež nosauktas kategorijas. Izsaucot to pirms ģenerēšanas, vari tīri atteikt, paskaidrot lietotājam, kas tika atzīmēts, un saglabāt šo informāciju revīzijai. Funkcija verify_prompt izgūst aktivizēto kategoriju sarakstu, bet generate_safe_image vienkārši sasaista abus soļus: vispirms pārbaudi, tad ģenerē.
from openai import OpenAI
client = OpenAI()
def verify_prompt(prompt: str) -> dict:
"""Pārbauda uzvedni ar Moderācijas API pirms ģenerēšanas."""
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": "Šo uzvedni atzīmēja moderācijas sistēma."
}
return {"allowed": True}
def generate_safe_image(prompt: str, output: str):
"""Pilna cauruļvada: moderācija + ģenerēšana."""
# 1. solis: iepriekšēja filtrēšana
check = verify_prompt(prompt)
if not check["allowed"]:
print(f"Uzvedne atteikta: {check['message']}")
print(f"Kategorijas: {check['categories']}")
return None
# 2. solis: ģenerēšana
print("Uzvedne apstiprināta, ģenerē...")
return generate_with_moderation(prompt, output)
# Tests ar nekaitīgu uzvedni
generate_safe_image(
"A mountain landscape with a crystal clear lake",
"mountain.png"
)
Pārbaudi arī ģenerētos attēlus
Nevainīga uzvedne var radīt attēlu, kas tāds nav. Aplinkus formulējums, termina neskaidrība vai vienkārši neveiksmīga modeļa interpretācija pietiek, lai radītu vizuālu saturu, ko negribētu rādīt zem sava logotipa. Modelis omni-moderation-latest pieņem attēlus kā ievadi, ļaujot noslēgt ciklu: tie paši kategoriju mehānismi attiecas uz ģenerēto failu. Tālāk esošajā pilnajā cauruļvadā ir sasaistīti trīs posmi — uzvednes pārbaude, ģenerēšana, attēla pārbaude — un, kas ir būtiski, atzīmēšanas gadījumā fails tiek dzēsts no diska pirms sprieduma atgriešanas. Problemātisks attēls, kas paliek serverī „kamēr pētām”, ir attēls, kas galu galā noplūdīs.
from openai import OpenAI
import base64
client = OpenAI()
def moderate_generated_image(image_path: str) -> dict:
"""Analizē ģenerētu attēlu, lai noteiktu problemātisku saturu."""
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):
"""Pilns cauruļvads: uzvednes moderācija + ģenerēšana + attēla moderācija."""
# 1. Pārbaudi uzvedni
check_prompt = verify_prompt(prompt)
if not check_prompt["allowed"]:
return {"status": "prompt_refused", "details": check_prompt}
# 2. Ģenerē attēlu
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. Pārbaudi ģenerēto attēlu
check_image = moderate_generated_image(output)
if not check_image["safe"]:
import os
os.remove(output)
return {
"status": "image_deleted",
"reason": "Ģenerētais attēls tika atzīmēts",
"categories": check_image["categories"]
}
return {"status": "ok", "path": output}
Kad uzvednes raksta lietotāji
Lietotāju ģenerēts saturs maina problēmas dabu: vairs nesaskaries tikai ar neveiklību, bet reizēm ar apzinātiem mēģinājumiem apiet aizsardzību. Klase PromptModerator sakrauj četras dažāda rakstura aizsardzības, kas ir nopietnas aizsardzības pamatprincips. Tīrīšana noņem vadības rakstzīmes, caur kurām notiek injicēšana, un ierobežo garumu līdz piecsimt rakstzīmēm, pārtraucot plūdu uzvednes, kas domātas instrukciju noslīcināšanai. Lokāla pārbaude, izmantojot aizliegto vārdu sarakstu (atstāts tukšs, aizpildi atbilstoši savai politikai un nozarei), par nulli izmaksām pārtver to, ko jau zini. Tad pārņem Moderācijas API visu, ko tavs saraksts neparedzēja. Visbeidzot, drošības prefikss, kas pievienots pirms galīgās uzvednes, eksplicīti atgādina modelim paredzēto ietvaru, nobīdot robežu par labu tev robežgadījumos.
from openai import OpenAI
import re
client = OpenAI()
class PromptModerator:
"""Daudzslāņu filtrs lietotāju uzvednēm."""
def __init__(self):
self.forbidden_words = [] # Aizpildi atbilstoši savai politikai
self.security_prefix = (
"Safe and appropriate image for all audiences. "
"No violent, sexual, or discriminatory content. "
)
def clean(self, prompt: str) -> str:
"""Attīra un normalizē lietotāja uzvedni."""
# Noņem potenciālās injicēšanas
prompt = prompt.strip()
# Ierobežo garumu
prompt = prompt[:500]
# Noņem vadības rakstzīmes
prompt = re.sub(r'[\x00-\x1f\x7f-\x9f]', '', prompt)
return prompt
def check_words(self, prompt: str) -> bool:
"""Pārbauda, vai nav aizliegtu vārdu."""
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:
"""Pievieno uzvednei drošības prefiksu."""
return f"{self.security_prefix}{prompt}"
def pipeline(self, raw_prompt: str) -> dict:
"""Pilns moderācijas cauruļvads lietotāja uzvednei."""
# 1. solis: tīrīšana
prompt = self.clean(raw_prompt)
# 2. solis: lokāla pārbaude
if not self.check_words(prompt):
return {"allowed": False, "reason": "Atklāts aizliegts vārds"}
# 3. solis: API moderācija
check = verify_prompt(prompt)
if not check["allowed"]:
return {"allowed": False, "reason": check["message"]}
# 4. solis: pievieno drošības prefiksu
final_prompt = self.secure(prompt)
return {"allowed": True, "prompt": final_prompt}
moderator = PromptModerator()
# Simulē lietotāja uzvedni
result = moderator.pipeline("A tabby cat sleeping on a red cushion")
if result["allowed"]:
print(f"Droša uzvedne: {result['prompt']}")
else:
print(f"Atteikts: {result['reason']}")
Žurnāli atbildībai
Dienā, kad problēmatisks attēls atkal parādās, jautājums, kas tev tiks uzdots, būs: kas to pieprasīja, kad un ko darīja tava sistēma. Bez žurnāliem tev nav atbildes. AuditLogger raksta vienu JSON rindiņu katrā ģenerēšanā uz .jsonl failu — tikai papildināms formāts, kas atbalsta vienlaicīgu rakstīšanu un ļauj lasīt rindu pa rindu, neielādējot visu atmiņā. Katrs ieraksts saista lietotāja ID ar saīsinātu uzvedni, ģenerēšanas iznākumu un, ja piemērojams, atteikuma iemeslu. Metode report tad aprēķina pieņemšanas koeficientu pēdējās simt ģenerēšanās laikā un detalizē atteikumus: šis ir informācijas panelis, kas tevi brīdinās, ja konkrēts konts uzkrāj atzīmes.
import json
import os
from datetime import datetime
class AuditLogger:
"""Attēlu ģenerēšanas revīzijas žurnāls."""
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
):
"""Ieraksta revīzijas ierakstu."""
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):
"""Ģenerē pārskatu par jaunākajām ģenerēšanām."""
if not os.path.exists(self.log_file):
print("Žurnāli nav atrasti.")
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"Pārskats par pēdējām {total} ģenerēšanām:")
print(f" Pieņemti: {ok} ({100*ok/total:.1f}%)")
print(f" Atteikti : {refused} ({100*refused/total:.1f}%)")
if refused > 0:
print(f"\nAtteikuma detaļas:")
for e in recent:
if e["result"] != "ok":
print(f" [{e['timestamp'][:10]}] {e['user_id']} : {e['refusal_reason']}")
logger = AuditLogger()
logger.report()
Autortiesības un preču zīmes
GPT Image spēj radīt attēlus, kas atgādina mākslinieka stilu vai zīmola vizuālo identitāti, un tieši šī spēja tevi pakļauj riskam. Tehniskā moderācija tevi šajā jomā neaizsargā: tā neatklāj, ka plakāts izskatās ļoti līdzīgs konkurenta plakātam. Aizsardzība tāpēc ir līgumiska un organizatoriska, rakstiskas, izpildāmas lietošanas politikas veidā, ko lietotāji pieņem, bet tava komanda ievēro. Bloks PRODUCTION_RULES sniedz minimālo formulējumu, kas jāparāda dokumentācijā un jāatgādina noteikumos.
# Labākā prakse, ko iekļaut lietošanas politikā
PRODUCTION_RULES = """
1. Nepieprasiet dzīva mākslinieka stila imitāciju pēc vārda
2. Nereproducējiet logotipus vai reģistrētas preču zīmes
3. Neģenerējiet reālu cilvēku sejas
4. Pievienojiet paziņojumu „AI ģenerēts attēls", ja tas ir prasīts
5. Saglabājiet ģenerēšanas žurnālus vismaz 12 mēnešus
6. Ļaujiet lietotājiem ziņot par problemātisku saturu
"""
def usage_warning():
"""Parāda ražošanas lietošanas noteikumus."""
print("=" * 60)
print("RAŽOŠANAS NOTEIKUMI — AI attēlu ģenerēšana")
print("=" * 60)
print(PRODUCTION_RULES)
Atbilstība VDAR (GDPR)
Eiropas uzņēmumam saglabāšanas periodi un piekrišana nav konfigurācijas opcijas, bet gan pienākumi, kuru ievērošana ir pierādāma. To fiksēšana eksplicītā konfigurācijas objektā, nevis izkaisīšana pa kodu, dod vienu vietu, ko parādīt revīzijas laikā. ComplianceConfig tādējādi iestata žurnālu saglabāšanu uz vienu gadu, attēlu saglabāšanu uz deviņdesmit dienām un padara AI paziņojumu un piekrišanu obligātus. Īpašu uzmanību pelnī metode add_ai_metadata: tā, izmantojot PngInfo, ieraksta pašā PNG failā faktu, ka attēls ir ģenerēts, rīku, kas to radījis, un datumu. Šie metadati ceļo kopā ar failu, arī ārpus tavas platformas, ko nespēj nodrošināt neviens tīmekļa lapā parādīts paziņojums.
class ComplianceConfig:
"""Atbilstības konfigurācija attēlu ģenerēšanai."""
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:
"""Pārbauda, vai lietotājs ir devis piekrišanu AI ģenerēšanai."""
# Implementē ar savu piekrišanas pārvaldības sistēmu
return True
def add_ai_metadata(self, image_path: str):
"""Pievieno metadatus, kas norāda uz AI ģenerēšanu."""
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"AI metadati pievienoti: {image_path}")
Pirms vārtu atvēršanas
Astoņi noteikumiem ir jābūt spēkā dienā, kad tava sistēma kļūst pieejama, un ir godīgāk par tiem jautāt pirms, nevis pēc. Pirmkārt, moderācija abos posmos: uzvedņu iepriekšēja filtrēšana un attēlu pēcpārbaude, kā to dara secure_pipeline. Tad žurnāli — pilnīgi, saistot katru ģenerēšanu ar uzvedni, autoru un iznākumu; tā ir tava vienīgā pierādījuma bāze strīda gadījumā, un tai ir jābūt saglabātai neatkarīgi no pašiem attēliem, pretējā gadījumā krātuves tīrīšana aiznesīs līdzi arī tavu izsekojamību.
Tad nāk lietotāja puse. Ātruma ierobežojums katram kontam novērš situāciju, kad viens abonents vienas nakts laikā iztērē tavu mēneša budžetu, vai nu apzināti, vai slikti uzrakstīta skripta dēļ. Informācija par attēlu ģenerēto dabu attiecas gan uz godīgumu, gan, arvien biežāk, uz regulatīviem ierobežojumiem; to dublē tehniska marķēšana faila PNG vai EXIF metadatos. Tiesības uz dzēšanu pieņem, ka spēj atrast un dzēst visa lietotāja datus pēc vienkārša pieprasījuma, kas ir iespējams tikai tad, ja tavi revīzijas ieraksti satur user_id. Visbeidzot, atver ziņošanas kanālu: tavi lietotāji vienmēr pamanīs problemātisko ātrāk par tevi, un atņemšana viņiem iespēju tev to pateikt nepazudina problēmu.
Tagad saliec visu vienotā attēlu ģenerēšanas servisā: uzvedņu iepriekšēja filtrēšana, izmantojot Moderācijas API un vārdu sarakstu, drošības prefikss, radītā attēla pēcpārbaude, revīzijas žurnāls un AI metadati katrā failā. Testē to ar piecām dažādām uzvednēm, no kurām vismaz vienai ir jābūt atteiktai — tikai tā vari pārbaudīt, vai tavi aizsargmehānismi patiešām strādā, nevis tikai eksistē kodā.
Pārbaudi savas zināšanas
Vizuālā ģenerēšana, izmantojot API: pārbaudi refleksus pirms ražošanas.
1. Ko ļauj inpainting un outpainting?
Atbilde: Inpainting modificē konkrētu esoša attēla apgabalu (aizstāj, labo); outpainting paplašina attēlu aiz tā sākotnējā ietvara — divi mērķtiecīgi labojumi, nepārģenerējot visu.
2. Kas padara labu uzlabotu vizuālo uzvedni?
Atbilde: Apraksti subjektu, kompozīciju, apgaismojumu un perspektīvu — ne tikai tēmu: jo vairāk uzvedne ierāmē ainu kā operators, jo vairāk attēls pakļaujas.
3. Kā efektīvi strādāt ar iterācijām?
Atbilde: Sāc ar bāzes ģenerēšanu, tad pieprasī mērķtiecīgas variācijas (stils, ietvars, detaļa), nevis pārraksti uzvedni no nulles — saglabā to, kas strādā, koriģē tikai atšķirības.
4. Kādi sviras ģenerēšanas izmaksu optimizēšanai?
Atbilde: Pielāgo kvalitāti un izšķirtspēju reālajai vajadzībai (melnraksti zemā, gala varianti augstā), ierobežo iterācijas ar labākām uzvednēm un kešē/atkārtoti izmanto apstiprinātus vizuālos materiālus.
5. Kāpēc vizuālā satura moderācija ir būtiska?
Atbilde: Tāpēc, ka API un tavi noteikumi uzliek ierobežojumus (aizliegts saturs, reāli cilvēki, zīmoli): uzvedņu filtrēšana un izejas kontrole aizsargā tavus lietotājus un tavu lietotni.
Ierāmē, iterē, apgūsti izmaksas un atbilstību: vizuālā ražošana ir cauruļvads, nevis ruletes rats.