Moderavimas ir vaizdinio turinio saugumas
Šiame puslapyje
Atnaujinta 2026 m. lapkričio 3 d. pagal OpenAI Vaizdų generavimo gidą: Moderavimo atsisakymas nustatomas pagal
error.code == "moderation_blocked"su neprivalomumoderation_detailsobjektu, o ne pagal žodžiųsafetyarbacontent_policybuvimą klaidos pranešime; pridėtasmoderationparametras (auto,low). Šaltinis: Vaizdų generavimas.
2026 m. lapkričio 2 d. atnaujinimas — Vaizdų modeliai.
gpt-image-1, kuriuo remiantis iš pradžių buvo rašomas šis kursas, buvo nutrauktas 2026 m. spalio 23 d., ogpt-image-1.5,gpt-image-1-miniirchatgpt-image-latestbus pašalinti 2026 m. gruodžio 1 d. Pavyzdžiuose dabar naudojamasgpt-image-2.5-sunburst, tiksliausias redagavimui;gpt-image-2.5-flareyra greitesnis standartiniam generavimui. Abu taip pat priimaxhighirmaxkokybes. GPT Image modeliai visada grąžina vaizdą base64 formatu: senesnių DALL·E modelių parametrasresponse_formatnėra priimamas ir buvo pašalintas iš kodo. Šaltinis: Vaizdų generavimas (OpenAI).
Moderavimas ir vaizdinio turinio saugumas
Kol generuoji vaizdus tik sau, moderavimas yra asmeninio sprendimo reikalas. Kai atveri generavimą naudotojams, tai tampa teisine ir etine atsakomybe, kuri tave įpareigoja. Šioje pamokoje aptarsime OpenAI moderavimo įrankius, kaip juos sujungti į nuoseklius filtrus ir kokios priemonės apsaugo tiek tavo programą, tiek žmones, kurie ja naudojasi.
Integruota moderavimo sistema
GPT Image pats atmeta tam tikrą turinį – smurtą, seksualinio pobūdžio medžiagą ir kita – ir apie šį atmetimą praneša specifine klaida. Todėl tavo kodas turi atskirti turinio politikos atsisakymą nuo techninio gedimo, nes šie du atvejai reikalauja priešingų veiksmų: pirmuoju atveju naudotojui siunčiamas pranešimas, antruoju – įspėjimas tavo komandai. OpenAI dokumentacijoje nurodytas diskriminatorius: moderavimo atsisakymas ateina kaip BadRequestError, kurio error.code lygus moderation_blocked (tipas image_generation_user_error), o klaidos kūne gali būti moderation_details objektas, nurodantis etapą (input, output arba unknown) ir bendras kategorijas (harassment, sexual, violence…). Neieškok žodžių klaidos pranešimo tekste: jo tekstas nėra sutartis, kodas yra. Toliau pateikta funkcija išmeta išimtį iš naujo tik tada, jei tai nėra moderavimo atsisakymas.
from openai import OpenAI, BadRequestError
client = OpenAI()
def generate_with_moderation(prompt: str, output: str) -> dict:
"""Generuoja vaizdą, tvarkydamas moderavimo atsisakymus."""
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 # techninis gedimas, kvota, neteisinga užklausa: tvarkyti kitur
body = e.body if isinstance(e.body, dict) else {}
details = body.get("moderation_details") or {}
return {
"status": "refused",
"reason": "Turinys atmestas dėl saugumo politikos",
"stage": details.get("moderation_stage"), # input, output arba unknown
"categories": details.get("categories") or [], # tavo žurnalams
}
result = generate_with_moderation(
"A kitten playing with a ball of yarn",
"kitten.png"
)
print(result)
OpenAI pataria galutiniam naudotojui palikti bendrą pranešimą, o moderation_details skirti tik tavo žurnalams ir pagalbai. Šios klaidos neišsprendžiamos kartojant bandymą: nepakeitus užuominos ar pateiktų vaizdų, tas pats prašymas vėl bus atmestas. Galiausiai atkreipk dėmesį, kad filtravimo griežtumą nustato GPT Image modelių parametras moderation: auto (standartinis filtravimas, numatytasis) arba low (mažiau ribojantis).
Užuominų išankstinis filtravimas
Laukti, kol GPT Image atmes užuominą, ir tik tada sužinoti, kad ji buvo problematiška, yra nepatenkinama: jau sunaudojai API kvietimą ir nieko konkrečiai nesužinojai apie priežastį. Tačiau Moderavimo API yra nemokamas, greitas ir grąžina įvardytas kategorijas. Iškvietus jį prieš generavimą, gali švariai atmesti užuominą, paaiškinti naudotojui, kas buvo pažymėta, ir išsaugoti šią informaciją auditui. Funkcija verify_prompt ištraukia suaktyvintų kategorijų sąrašą, o generate_safe_image tiesiog sujungia du žingsnius: pirmiausia patikrina, paskui generuoja.
from openai import OpenAI
client = OpenAI()
def verify_prompt(prompt: str) -> dict:
"""Patikrina užuominą naudojant Moderavimo API prieš generavimą."""
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": "Ši užuomina buvo pažymėta moderavimo sistemos."
}
return {"allowed": True}
def generate_safe_image(prompt: str, output: str):
"""Pilnas procesas: moderavimas + generavimas."""
# 1 žingsnis: išankstinis filtravimas
check = verify_prompt(prompt)
if not check["allowed"]:
print(f"Užuomina atmesta: {check['message']}")
print(f"Kategorijos: {check['categories']}")
return None
# 2 žingsnis: generavimas
print("Užuomina patvirtinta, generuojama...")
return generate_with_moderation(prompt, output)
# Testavimas su nekenksminga užuomina
generate_safe_image(
"A mountain landscape with a crystal clear lake",
"mountain.png"
)
Tikrink ir sugeneruotus vaizdus
Nekalta užuomina gali sukurti vaizdą, kuris toks nėra. Užuolankus formulavimas, termino dviprasmybė arba tiesiog nepavykusi modelio interpretacija pakanka, kad atsirastų vaizdinis turinys, kurio nenorėtum matyti po savo logotipu. Modelis omni-moderation-latest kaip įvestį priima vaizdus, todėl gali užbaigti ciklą: tos pačios kategorijų taisyklės taikomos ir sugeneruotam failui. Toliau pateiktame pilname procese sujungti trys etapai – užuominos tikrinimas, generavimas, vaizdo tikrinimas – ir, svarbiausia, pažymėjus problemą, failas ištrinamas iš disko prieš grąžinant verdiktą. Probleminis vaizdas, paliktas serveryje „kol pasižiūrėsime“, yra vaizdas, kuris anksčiau ar vėliau nutekės.
from openai import OpenAI
import base64
client = OpenAI()
def moderate_generated_image(image_path: str) -> dict:
"""Analizuoja sugeneruotą vaizdą, aptinkant problematišką turinį."""
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):
"""Pilnas procesas: užuominos moderavimas + generavimas + vaizdo moderavimas."""
# 1. Patikrink užuominą
check_prompt = verify_prompt(prompt)
if not check_prompt["allowed"]:
return {"status": "prompt_refused", "details": check_prompt}
# 2. Sugeneruok vaizdą
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. Patikrink sugeneruotą vaizdą
check_image = moderate_generated_image(output)
if not check_image["safe"]:
import os
os.remove(output)
return {
"status": "image_deleted",
"reason": "Sugeneruotas vaizdas buvo pažymėtas",
"categories": check_image["categories"]
}
return {"status": "ok", "path": output}
Kai užuominas rašo naudotojai
Naudotojų kuriamas turinys keičia problemos pobūdį: susiduri nebe su netyčiniais nusižengimais, o kartais ir su tyčiniais bandymais apeiti taisykles. Klasė PromptModerator sujungia keturias skirtingo pobūdžio gynybos linijas – tai ir yra rimtos apsaugos principas. Valymas pašalina valdymo simbolius, kuriais keliauja injekcijos, ir apriboja ilgį iki penkių šimtų simbolių, taip sustabdydamas „potvynio“ užuominas, skirtas nuskandinti instrukcijas. Vietinis tikrinimas pagal draudžiamų žodžių sąrašą (paliktas tuščias, kad jį užpildytum pagal savo politiką ir sektorių) nuliniu kaštu perima tai, ką jau žinai. Tada Moderavimo API perima viską, ko tavo sąrašas nenumatė. Galiausiai saugumo priešdėlis, pridėtas prieš galutinę užuominą, aiškiai primena modeliui numatytas ribas, palenkdamas pusiausvyrą tavo naudai ribiniais atvejais.
from openai import OpenAI
import re
client = OpenAI()
class PromptModerator:
"""Daugiasluoksnis naudotojų užuominų filtras."""
def __init__(self):
self.forbidden_words = [] # Užpildyk pagal savo politiką
self.security_prefix = (
"Saugus ir tinkamas vaizdas visoms auditorijoms. "
"Jokio smurto, seksualinio ar diskriminacinio turinio. "
)
def clean(self, prompt: str) -> str:
"""Išvalo ir normalizuoja naudotojo užuominą."""
# Pašalink potencialias injekcijas
prompt = prompt.strip()
# Apribok ilgį
prompt = prompt[:500]
# Pašalink valdymo simbolius
prompt = re.sub(r'[\x00-\x1f\x7f-\x9f]', '', prompt)
return prompt
def check_words(self, prompt: str) -> bool:
"""Patikrina, ar nėra draudžiamų žodžių."""
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:
"""Prideda saugumo priešdėlį prie užuominos."""
return f"{self.security_prefix}{prompt}"
def pipeline(self, raw_prompt: str) -> dict:
"""Pilnas naudotojo užuominos moderavimo procesas."""
# 1 žingsnis: valymas
prompt = self.clean(raw_prompt)
# 2 žingsnis: vietinis tikrinimas
if not self.check_words(prompt):
return {"allowed": False, "reason": "Aptiktas draudžiamas žodis"}
# 3 žingsnis: API moderavimas
check = verify_prompt(prompt)
if not check["allowed"]:
return {"allowed": False, "reason": check["message"]}
# 4 žingsnis: pridėk saugumo priešdėlį
final_prompt = self.secure(prompt)
return {"allowed": True, "prompt": final_prompt}
moderator = PromptModerator()
# Simuliuok naudotojo užuominą
result = moderator.pipeline("A tabby cat sleeping on a red cushion")
if result["allowed"]:
print(f"Saugi užuomina: {result['prompt']}")
else:
print(f"Atmesta: {result['reason']}")
Žurnalų vedimas atsakomybei užtikrinti
Tą dieną, kai iškils problematiškas vaizdas, tau bus задаtas klausimas: kas jo paprašė, kada ir ką tavo sistema darė. Be žurnalų neturėsi atsakymo. AuditLogger į .jsonl failą rašo vieną JSON eilutę kiekvienam generavimui – tai tik papildomas formatas, palaikantis lygiagretų rašymą ir leidžiantis skaityti eilutę po eilutės neįkeliant visko į atmintį. Kiekvienas įrašas susieja naudotojo ID su sutrumpinta užuomina, generavimo rezultatu ir, jei taikoma, atsisakymo priežastimi. Metodas report tada apskaičiuoja priėmimo rodiklį per paskutinius šimtą generavimų ir išsamiai aprašo atsisakymus: tai yra skydelis, kuris tave įspės, jei tam tikra paskyra kaupia žymas.
import json
import os
from datetime import datetime
class AuditLogger:
"""Vaizdų generavimo audito žurnalas."""
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
):
"""Įrašo audito įrašą."""
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):
"""Generuoja paskutinių generavimų ataskaitą."""
if not os.path.exists(self.log_file):
print("Žurnalų nerasta.")
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"Paskutinių {total} generavimų ataskaita:")
print(f" Priimta: {ok} ({100*ok/total:.1f}%)")
print(f" Atmesta : {refused} ({100*refused/total:.1f}%)")
if refused > 0:
print(f"\nAtsisakymo detalės:")
for e in recent:
if e["result"] != "ok":
print(f" [{e['timestamp'][:10]}] {e['user_id']} : {e['refusal_reason']}")
logger = AuditLogger()
logger.report()
Autorių teisės ir prekių ženklai
GPT Image moka kurti vaizdus, kurie primena menininko stilių arba prekės ženklo vizualinį identitetą, ir būtent ši galimybė tave eksponuoja. Techninis moderavimas šiuo klausimu tavęs neapsaugo: jis nepastebi, kad plakatas labai panašus į konkurento. Todėl apsauga yra sutartinė ir organizacinė – tai rašytinė, vykdytina naudojimo politika, kurią priima tavo naudotojai ir taiko tavo komanda. Blokas PRODUCTION_RULES pateikia minimalią formuluotę, kurią turi rodyti savo dokumentacijoje ir priminti savo sąlygose.
# Geriausios praktikos, integruotinos į naudojimo politiką
PRODUCTION_RULES = """
1. Neprašyk imituoti gyvo menininko stiliaus pagal vardą
2. Neatkartok logotipų arba registruotų prekių ženklų
3. Negeneruok realių žmonių veidų
4. Prireikus pridėk pastabą „AI sugeneruotas vaizdas“
5. Saugok generavimo žurnalus bent 12 mėnesių
6. Leisk naudotojams pranešti apie problematišką turinį
"""
def usage_warning():
"""Rodo gamybos naudojimo taisykles."""
print("=" * 60)
print("GAMYBOS TAISYKLĖS — DI dirbtinių vaizdų generavimas")
print("=" * 60)
print(PRODUCTION_RULES)
Atitiktis BDAR (GDPR)
Europos įmonei saugojimo terminai ir sutikimas nėra konfigūracijos parinktys, o įpareigojimai, kurių laikymasis turi būti įrodomas. Įrašius juos į aiškų konfigūracijos objektą, o ne išbarščius per kodą, turėsi vieną vietą, kurią galėsi parodyti audito metu. ComplianceConfig nustato žurnalų saugojimą vieneriems metams, vaizdų – devyniasdešimčiai dienų, ir daro privalomais DI pastabą bei sutikimą. Ypatingo dėmesio nusipelno metodas add_ai_metadata: jis įrašo tiesiai į PNG failą, naudodamas PngInfo, faktą, kad vaizdas sugeneruotas, įrankį, kuris jį sukūrė, ir datą. Šie metaduomenys keliauja kartu su failu, net ir už tavo platformos ribų – to negali padaryti joks pranešimas, rodomas tinklalapyje.
class ComplianceConfig:
"""Vaizdų generavimo atitikties konfigūracija."""
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:
"""Patikrina, ar naudotojas davė sutikimą DI generavimui."""
# Įgyvendink su savo sutikimų valdymo sistema
return True
def add_ai_metadata(self, image_path: str):
"""Prideda metaduomenis, nurodančius DI generavimą."""
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"DI metaduomenys pridėti: {image_path}")
Prieš atveriant vartus
Aštuonios nuostatos turi būti įgyvendintos tą dieną, kai tavo sistema tampa prieinama, ir sąžiningiau jų paprašyti prieš, o ne po. Pirmiausia – moderavimas dviem etapais: užuominų išankstinis filtravimas ir sugeneruotų vaizdų patikrinimas po to, kaip tai daro secure_pipeline. Toliau – išsamus žurnalų vedimas, siejantis kiekvieną generavimą su jo užuomina, autoriumi ir rezultatu; tai vienintelis tavo įrodymas ginčo atveju, ir jis turi būti saugomas nepriklausomai nuo pačių vaizdų, kitaip saugyklos išvalymas ištrintų ir tavo atsekamumą.
Tada eina naudotojų pusė. Paskyros užklausų dažnio ribojimas neleidžia vienam prenumeratoriui per vieną naktį sunaudoti tavo mėnesinio biudžeto – tyčia arba dėl blogai parašyto scenarijaus. Informacija apie sugeneruotą vaizdų pobūdį susijusi tiek su sąžiningumu, tiek, vis labiau, su reguliavimo reikalavimais; ji papildoma techniniu žymėjimu failo PNG arba EXIF metaduomenyse. Teisė būti pamirštam reiškia, kad paprasto prašymo pagrindu gali rasti ir ištrinti visus naudotojo duomenis, o tai įmanoma tik tada, jei tavo audito įrašuose yra user_id. Galiausiai atverk pranešimų kanalą: tavo naudotojai visada pastebės tai, kas problematiška, anksčiau nei tu, o atimti iš jų galimybę tau apie tai pranešti neišsprendžia problemos.
Dabar sujunk visa tai į vieną vaizdų generavimo servisą: užuominų išankstinis filtravimas naudojant Moderavimo API ir žodžių sąrašą, saugumo priešdėlis, sugeneruoto vaizdo patikrinimas po to, audito žurnalas ir DI metaduomenys kiekviename faile. Ištestuok jį su penkiomis įvairiomis užuominomis, iš kurių bent viena turi būti atmesta – tai vienintelis būdas patikrinti, ar tavo apsaugos mechanizmai iš tikrųjų veikia, o ne tik yra kode.
Patikrink savo žinias
Vaizdų generavimas per API: patvirtink refleksus prieš gamybą.
1. Ką leidžia daryti inpainting ir outpainting?
Atsakymas: Inpainting modifikuoja konkrečią esamo vaizdo sritį (pakeičia, taiso); outpainting pratęsia vaizdą už jo originalių rėmų – du tiksliniai redagavimai negeneruojant visko iš naujo.
2. Kas sudaro gerą pažangią vaizdinę užuominą?
Atsakymas: Aprašyk objektą, kompoziciją, apšvietimą ir perspektyvą – ne tik temą: kuo labiau užuomina kadruoja sceną kaip operatorius, tuo labiau vaizdas paklūsta.
3. Kaip efektyviai dirbti iteracijomis?
Atsakymas: Pradėk nuo bazinio generavimo, tada prašyk tikslinių variacijų (stilius, kadras, detalės), o ne rašyk užuominą iš naujo – palik tai, kas veikia, ir koreguok tik skirtumus.
4. Kokius svertus naudoti generavimo išlaidoms optimizuoti?
Atsakymas: Pritaikyk kokybę ir skiriamąją gebą realiam poreikiui (juodraščiai – žema, galutiniai – aukšta), apribok iteracijas geresnėmis užuominomis ir talpykloje saugok bei pakartotinai naudok patvirtintus vaizdus.
5. Kodėl vaizdinio turinio moderavimas yra esminis?
Atsakymas: Nes API ir tavo sąlygos nustato ribas (draudžiamas turinys, realūs žmonės, prekių ženklai): užuominų filtravimas ir išvesties kontrolė apsaugo tavo naudotojus ir tavo programą.
Kadruok, kartok, valdyk išlaidas ir atitiktį: vaizdų gamyba yra procesas, o ne atsitiktinumas.