Moderatsioon ja visuaalse sisu turvalisus
Sellel lehel
Uuendatud 3. novembril 2026 vastavalt OpenAI pildigeneratsiooni juhendile: moderatsiooni tagasilükkamine tuvastatakse koodiga
error.code == "moderation_blocked"ja valikulise objektigamoderation_details, mitte sõnadesafetyvõicontent_policyolemasoluga veateates; lisatud parameetermoderation(auto,low). Allikas: Pildigeneratsioon.
2. novembri 2026 uuendus — Pildimudelid.
gpt-image-1, mille põhjal see kursus algselt kirjutati, lõpetati 23. oktoobril 2026 ning mudelidgpt-image-1.5,gpt-image-1-minijachatgpt-image-latestretireeritakse 1. detsembril 2026. Näited kasutavad nüüd mudelitgpt-image-2.5-sunburst, mis on redigeerimisel kõige täpsem;gpt-image-2.5-flareon tavapäraseks generatsiooniks kiirem. Mõlemad aktsepteerivad ka kvaliteetexhighjamax. GPT Image mudelid tagastavad pildi alati base64-koodingus: vanematelt DALL·E mudelitelt pärit parameetritresponse_formatei aktsepteerita ja see on koodist eemaldatud. Allikas: Pildigeneratsioon (OpenAI).
Moderatsioon ja visuaalse sisu turvalisus
Seni, kuni genereerid pilte ainult enda jaoks, on moderatsioon isikliku otsustamise küsimus. Kui avad generatsiooni kasutajatele, muutub see juriidiliseks ja eetiliseks vastutuseks, mis sind seob. See tund käsitleb OpenAI moderatsioonitööriistu, viisi, kuidas need järjestikusteks filtriteks aheldada, ning meetmeid, mis kaitsevad nii sinu rakendust kui ka inimesi, kes seda kasutavad.
Sisseehitatud moderatsioonisüsteem
GPT Image keeldub teatud sisust iseseisvalt – vägivald, seksuaalselt eksplitsiitne materjal ja muu – ning annab sellest keeldumisest märku konkreetse veaga. Sinu kood peab seetõttu eristama sisupoliitika põhjal tehtud keeldumist tehnilisest rikkest, sest need nõuavad vastupidist reaktsiooni: esimesel juhul saadad kasutajale teate, teisel juhul teavitad oma meeskonda. OpenAI dokumentatsioon täpsustab kasutatavat eristajat: moderatsiooni tagasilükkamine saabub kui BadRequestError, kus error.code on võrdne väärtusega moderation_blocked (tüüp image_generation_user_error), ja vea keha võib sisaldada objekti moderation_details, mis täpsustab etappi (input, output või unknown) ning üldkategooriaid (harassment, sexual, violence…). Ära otsi sõnu veateatest: selle tekst ei ole leping, kood on. Allpool olev funktsioon viskab erandi uuesti välja ainult siis, kui tegemist ei ole moderatsiooni tagasilükkamisega.
from openai import OpenAI, BadRequestError
client = OpenAI()
def generate_with_moderation(prompt: str, output: str) -> dict:
"""Generates an image while handling moderation refusals."""
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 # technical failure, quota, invalid request: handle elsewhere
body = e.body if isinstance(e.body, dict) else {}
details = body.get("moderation_details") or {}
return {
"status": "refused",
"reason": "Content refused by safety policy",
"stage": details.get("moderation_stage"), # input, output or unknown
"categories": details.get("categories") or [], # for your logs
}
result = generate_with_moderation(
"A kitten playing with a ball of yarn",
"kitten.png"
)
print(result)
OpenAI soovitab hoida lõppkasutaja jaoks üldist teadet ja reserveerida moderation_details oma logide ja tugiteenuse jaoks. Need vead ei lahene uuesti proovides: ilma vihjet või pakutud pilte muutmata lükatakse sama päring uuesti tagasi. Pane tähele ka seda, et filtreerimise ranguse määrab GPT Image mudelite parameeter moderation: auto (standardne filtreerimine, vaikimisi) või low (vähem piirav).
Vihjete eelfiltreerimine
Ootamine, kuni GPT Image vihje tagasi lükkab, enne kui avastad selle problemaatiliseks olemist, on ebapiisav: oled juba API päringu ära tarbinud ja ei saa teada konkreetset põhjust. Moderatsiooni API on aga tasuta, kiire ja tagastab nimetatud kategooriad. Selle kutsumine enne generatsiooni võimaldab sul puhtalt keelduda, selgitada kasutajale, mis märgistati, ja säilitada see teave auditeerimiseks. Funktsioon verify_prompt ekstraheerib käivitatud kategooriate loendi ja generate_safe_image lihtsalt aheldab kaks sammu: kõigepealt kontroll, seejärel generatsioon.
from openai import OpenAI
client = OpenAI()
def verify_prompt(prompt: str) -> dict:
"""Checks a prompt with the Moderation API before generation."""
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": "This prompt was flagged by the moderation system."
}
return {"allowed": True}
def generate_safe_image(prompt: str, output: str):
"""Complete pipeline: moderation + generation."""
# Step 1: pre-filtering
check = verify_prompt(prompt)
if not check["allowed"]:
print(f"Prompt refused: {check['message']}")
print(f"Categories: {check['categories']}")
return None
# Step 2: generation
print("Prompt validated, generating...")
return generate_with_moderation(prompt, output)
# Test with a harmless prompt
generate_safe_image(
"A mountain landscape with a crystal clear lake",
"mountain.png"
)
Kontrolli ka genereeritud pilte
Süütu vihje võib anda tulemuseks pildi, mis seda pole. Ümberütlemine, termini mitmetimõistetavus või lihtsalt ebaõnnestunud mudeli tõlgendus võib piisata visuaalse sisu loomiseks, mida sa ei tahaks oma logo all näidata. Mudel omni-moderation-latest aktsepteerib sisendina pilte, võimaldades sul ahela sulgeda: samad kategooria mehhanismid kehtivad genereeritud faili kohta. Allpool olev täielik torustik aheldab kolm faasi – vihje kontroll, generatsioon, pildi kontroll – ja mis on kriitiline: lipu korral kustutatakse fail kettalt enne otsuse tagastamist. Probleemne pilt, mis jääb serverisse „seniks, kuni vaatame“, on pilt, mis lõpuks lekib.
from openai import OpenAI
import base64
client = OpenAI()
def moderate_generated_image(image_path: str) -> dict:
"""Analyzes a generated image to detect problematic content."""
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):
"""Complete pipeline: prompt moderation + generation + image moderation."""
# 1. Check the prompt
check_prompt = verify_prompt(prompt)
if not check_prompt["allowed"]:
return {"status": "prompt_refused", "details": check_prompt}
# 2. Generate the image
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. Check the generated image
check_image = moderate_generated_image(output)
if not check_image["safe"]:
import os
os.remove(output)
return {
"status": "image_deleted",
"reason": "Generated image was flagged",
"categories": check_image["categories"]
}
return {"status": "ok", "path": output}
Kui kasutajad kirjutavad vihjeid
Kasutaja loodud sisu muudab probleemi olemust: sa ei tegele enam kohmakusega, vaid mõnikord tahtlike katsetega süsteemist mööda hiilida. Klass PromptModerator virnastab nelja erinevat laadi kaitset, mis on tõsise kaitse printsiip ise. Puhastamine eemaldab juhtmärgid, mille kaudu injektsioonid liiguvad, ja piirab pikkuse viiesaja märgiga, lõigates ära üleujutusvihjed, mis on mõeldud juhiste uputamiseks. Kohalik kontroll keelatud sõnade nimekirja abil – jäetud tühjaks, et täita vastavalt sinu poliitikale ja sektorile – püüab nullkuluga kinni selle, mida juba tead. Seejärel võtab Moderatsiooni API üle kõik, mida sinu nimekiri ei ennustanud. Lõpuks tuletab turvalisuse prefiks, liidetud enne lõplikku vihjet, mudelile sõnaselgelt meelde oodatavat raamistikku, nihutades piiri äärmusjuhtudel sinu kasuks.
from openai import OpenAI
import re
client = OpenAI()
class PromptModerator:
"""Multi-layer filter for user prompts."""
def __init__(self):
self.forbidden_words = [] # Fill according to your policy
self.security_prefix = (
"Safe and appropriate image for all audiences. "
"No violent, sexual, or discriminatory content. "
)
def clean(self, prompt: str) -> str:
"""Cleans and normalizes a user prompt."""
# Remove potential injections
prompt = prompt.strip()
# Limit length
prompt = prompt[:500]
# Remove control characters
prompt = re.sub(r'[\x00-\x1f\x7f-\x9f]', '', prompt)
return prompt
def check_words(self, prompt: str) -> bool:
"""Checks for absence of forbidden words."""
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:
"""Adds a security prefix to the prompt."""
return f"{self.security_prefix}{prompt}"
def pipeline(self, raw_prompt: str) -> dict:
"""Complete moderation pipeline for a user prompt."""
# Step 1: cleaning
prompt = self.clean(raw_prompt)
# Step 2: local verification
if not self.check_words(prompt):
return {"allowed": False, "reason": "Forbidden word detected"}
# Step 3: API moderation
check = verify_prompt(prompt)
if not check["allowed"]:
return {"allowed": False, "reason": check["message"]}
# Step 4: add security prefix
final_prompt = self.secure(prompt)
return {"allowed": True, "prompt": final_prompt}
moderator = PromptModerator()
# Simulate a user prompt
result = moderator.pipeline("A tabby cat sleeping on a red cushion")
if result["allowed"]:
print(f"Secure prompt: {result['prompt']}")
else:
print(f"Refused: {result['reason']}")
Logimine aruandluskohustuse täitmiseks
Päeval, mil probleemne pilt uuesti pinnale tõuseb, on küsimus, mida sinult küsitakse: kes selle tellis, millal ja mida sinu süsteem tegi. Ilma logideta pole sul vastust. AuditLogger kirjutab ühe JSON-realise kirje generatsiooni kohta faili .jsonl – see on ainult lisamisrežiimis vorming, mis toetab samaaegset kirjutamist ja mida saab rida-realt lugeda ilma kõike mällu laadimata. Iga kirje seob kasutaja ID lühendatud vihjega, generatsiooni tulemusega ja vajadusel tagasilükkamise põhjusega. Meetod report tuletab seejärel vastuvõtmismäära viimase saja generatsiooni põhjal ja detailselt tagasilükkamised: see on armatuurlaud, mis hoiatab sind, kui konkreetne konto kogub lippe.
import json
import os
from datetime import datetime
class AuditLogger:
"""Audit log for image generations."""
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
):
"""Logs an audit entry."""
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):
"""Generates a report of recent generations."""
if not os.path.exists(self.log_file):
print("No logs found.")
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 of last {total} generations:")
print(f" Accepted: {ok} ({100*ok/total:.1f}%)")
print(f" Refused : {refused} ({100*refused/total:.1f}%)")
if refused > 0:
print(f"\nRefusal details:")
for e in recent:
if e["result"] != "ok":
print(f" [{e['timestamp'][:10]}] {e['user_id']} : {e['refusal_reason']}")
logger = AuditLogger()
logger.report()
Autoriõigus ja kaubamärgid
GPT Image oskab luua pilte, mis äratavad esile kunstniku stiili või brändi visuaalse identiteedi, ja just see võimekus sind ohustab. Tehniline moderatsioon sind selles osas ei kaitse: see ei tuvasta, et plakat näeb välja väga sarnane konkurendi omale. Kaitse on seetõttu lepinguline ja organisatsiooniline, väljendudes kirjalikus ja jõustatavas kasutamispoliitikas, mida sinu kasutajad aktsepteerivad ja sinu meeskond rakendab. Plokk PRODUCTION_RULES annab minimaalse sõnastuse, mis tuleb kuvada sinu dokumentatsioonis ning meenutada tingimustes.
# Best practices to integrate into your usage policy
PRODUCTION_RULES = """
1. Do not request imitation of a living artist's style by name
2. Do not reproduce logos or registered trademarks
3. Do not generate faces of real people
4. Add an "AI-generated image" notice when required
5. Retain generation logs for at least 12 months
6. Allow users to report problematic content
"""
def usage_warning():
"""Displays production usage rules."""
print("=" * 60)
print("PRODUCTION RULES — AI Image Generation")
print("=" * 60)
print(PRODUCTION_RULES)
Vastavus GDPR-ile
Euroopa ettevõtte jaoks ei ole säilitustähtajad ja nõusolekud konfiguratsioonivalikud, vaid kohustused, mille täitmist tuleb tõendada. Nende salvestamine selgesse konfiguratsiooniobjekti, mitte koodi laiali pillutamine, annab sulle auditi ajal ühe koha, mida näidata. ComplianceConfig seab seega logide säilitusajaks ühe aasta, piltide säilitusajaks üheksakümmend päeva ja teeb AI-teatise ning nõusoleku kohustuslikuks. Meetod add_ai_metadata väärib erilist tähelepanu: see kirjutab otse PNG-faili, kasutades PngInfo, fakti, et pilt on genereeritud, tööriista, mis selle lõi, ja kuupäeva. Need metaandmed reisivad failiga kaasas, ka väljaspool sinu platvormi, mida ükski veebilehel kuvatav teade ei tee.
class ComplianceConfig:
"""Compliance configuration for image generation."""
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:
"""Verifies that the user has consented to AI generation."""
# Implement with your consent management system
return True
def add_ai_metadata(self, image_path: str):
"""Adds metadata indicating AI generation."""
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 metadata added: {image_path}")
Enne lüüside avamist
Kaheksa sätet peavad olema paigas päeval, mil sinu süsteem muutub ligipääsetavaks, ja ausam on neid küsida enne kui pärast. Esiteks moderatsioon oma kahes faasis: vihjete eelfiltreerimine ja piltide järelkontroll, nagu secure_pipeline teeb. Seejärel logimine, täielik, seostades iga generatsiooni selle vihje, autori ja tulemusega – see on sinu ainus tõend vaidluse korral ja see tuleb salvestada sõltumatult piltidest endist, vastasel juhul viib salvestusruumi puhastamine kaasa ka sinu jälgitavuse.
Siis tuleb kasutaja pool. Määra piirang kontole, et vältida olukorda, kus üks tellija tarbib sinu kuu eelarvet ühe ööga, kas tahtlikult või halvasti kirjutatud skripti tõttu. Teave piltide genereeritud olemuse kohta puudutab nii ausust kui ka üha enam regulatiivset nõuet; seda toetab tehniline märgistus faili PNG või EXIF metaandmetes. Kustutamisõigus eeldab, et suudad lihtsal taotlusel leida ja kustutada kõik kasutaja andmed, mis on võimalik ainult siis, kui sinu auditi kirjed kannavad user_id. Lõpuks ava raportikanal: sinu kasutajad näevad alati problemaatilist sisu enne sind ja nende võimaluse ära võtmine sulle sellest teada anda ei pane probleemi kaduma.
Nüüd pane kogu see kokku üheks pildigeneratsiooni teenuseks: vihjete eelfiltreerimine Moderatsiooni API ja sõnaloendi kaudu, turvalisuse prefiks, loodud pildi järelkontroll, auditi logi ja AI-metaandmed igal failil. Testi seda viie erineva vihjega, millest vähemalt üks peab tagasi lükatama – see on ainus viis kontrollida, kas sinu kaitseraudteed tegelikult töötavad, mitte lihtsalt koodis ei eksisteeri.
Testi oma teadmisi
Visuaalne generatsioon API kaudu: valideeri refleksid enne tootmist.
1. Mida võimaldavad inpainting ja outpainting?
Vastus: Inpainting muudab olemasoleva pildi kindlat piirkonda (asendamine, parandamine); outpainting laiendab pilti väljapoole selle algset raami – kaks sihipärast redigeerimist ilma kõike uuesti genereerimata.
2. Mis teeb täiustatud visuaalsest vihjest hea?
Vastus: Kirjelda subjekti, kompositsiooni, valgustust ja perspektiivi – mitte ainult teemat: mida rohkem raamib vihje stseeni nagu filmioperaator, seda kuulekam on pilt.
3. Kuidas iteratsioonidega tõhusalt töötada?
Vastus: Alusta baasgeneratsioonist ja seejärel taotle sihipäraseid variatsioone (stiil, kaader, detail), mitte ära kirjuta vihjet nullist – säilita see, mis toimib, ja kohanda vaid puudujääki.
4. Millid hoovad generatsioonikulude optimeerimiseks?
Vastus: Kohanda kvaliteet ja eraldusvõime tegelikule vajadusele (mustandid madalas, lõplikud kõrges), piira iteratsioone paremate vihjetega ja vahemällu salvesta/kasuta uuesti valideeritud visuaale.
5. Miks on visuaalse sisu moderatsioon hädavajalik?
Vastus: Sest API ja sinu tingimused kehtestavad piirangud (keelatud sisu, reaalsed inimesed, brändid): vihjete filtreerimine ja väljundite kontrollimine kaitseb sinu kasutajaid ja rakendust.
Raami, iteratsiooni, valda kulusid ja vastavust: visuaalne tootmine on torustik – mitte täringu veeretamine.