Moderálás és vizuális tartalmak biztonsága
Ezen az oldalon
Frissítve: 2026. november 3. az OpenAI Képgenerálás útmutatója alapján: A moderációs elutasítást az
error.code == "moderation_blocked"azonosítja, opcionálismoderation_detailsobjektummal, nem pedig a hibaüzenetben szereplősafetyvagycontent_policyszavak jelenléte alapján; hozzáadtuk amoderationparamétert (auto,low). Forrás: Képgenerálás.
2026. november 2-i frissítés — Képmodellek. A
gpt-image-1, amelyre ezt a tananyagot eredetileg írtuk, 2026. október 23-án megszűnt, agpt-image-1.5,gpt-image-1-miniéschatgpt-image-latestmodellek pedig 2026. december 1-jén kerülnek kivonásra. A példák most agpt-image-2.5-sunburstmodellt használják, amely a legpontosabb szerkesztéshez; agpt-image-2.5-flaregyorsabb az általános generáláshoz. Mindkettő elfogadja azxhighésmaxminőségeket is. A GPT Image modellek mindig base64 formátumban adják vissza a képet: a régebbi DALL·E modellekből ismertresponse_formatparamétert nem fogadják el, ezért eltávolítottuk a kódból. Forrás: Képgenerálás (OpenAI).
Moderálás és vizuális tartalmak biztonsága
Amíg csak magadnak generálsz képeket, a moderálás egyéni megítélés kérdése. Ha azonban megnyitod a generálást a felhasználók előtt, az jogi és etikai felelősséggé válik, amely kötelez téged. Ez a lecke az OpenAI moderációs eszközeit mutatja be, azt, hogyan láncolhatod össze őket egymást követő szűrőkként, valamint azokat az intézkedéseket, amelyek védik mind az alkalmazásodat, mind pedig az azt használó embereket.
A beépített moderációs rendszer
A GPT Image önmagában is visszautasít bizonyos tartalmakat – például az erőszakot vagy a szexuális jellegű anyagokat –, és ezt egy specifikus hibajelzéssel kommunikálja. A kódodnak ezért meg kell különböztetnie a tartalmi szabályzat miatti elutasítást a technikai hibától, mivel a kettő ellentétes reakciót igényel: az előbbi esetén üzenetet küldesz a felhasználónak, az utóbbi esetén pedig riasztod a csapatodat. Az OpenAI dokumentációja pontosan meghatározza a megkülönböztetéshez szükséges elemet: a moderációs elutasítás egy BadRequestError kivételként érkezik, ahol az error.code értéke moderation_blocked (típusa: image_generation_user_error), és a hiba törzse tartalmazhat egy moderation_details objektumot, amely meghatározza a szakaszt (input, output vagy unknown) és az általános kategóriákat (harassment, sexual, violence…). Ne szavakat keress a hibaüzenetben: annak szövege nem szerződéses erejű, a kód az. Az alábbi függvény csak akkor dobja újra a kivételt, ha az nem moderációs elutasítás.
from openai import OpenAI, BadRequestError
client = OpenAI()
def generate_with_moderation(prompt: str, output: str) -> dict:
"""Képet generál, kezelve a moderációs elutasításokat."""
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 # technikai hiba, kvóta, érvénytelen kérés: máshol kezeld
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 vagy unknown
"categories": details.get("categories") or [], # a naplóidhoz
}
result = generate_with_moderation(
"A kitten playing with a ball of yarn",
"kitten.png"
)
print(result)
Az OpenAI azt tanácsolja, hogy a végfelhasználó számára általános üzenetet tarts fenn, a moderation_details adatokat pedig csak a naplóidhoz és az ügyfélszolgálathoz használd. Ezek a hibák újrapróbálkozásra sem oldódnak meg: a prompt vagy a megadott képek módosítása nélkül ugyanaz a kérés újra el lesz utasítva. Végül vedd figyelembe, hogy a szűrés szigorúságát a GPT Image modellek moderation paramétere állítja be: auto (szabványos szűrés, alapértelmezett) vagy low (kevésbé korlátozó).
Promptok előszűrése
Nem kielégítő megvárni, amíg a GPT Image elutasít egy promptot, mielőtt rájönnél, hogy problémás volt: már elhasználtál egy API-hívást, és semmit sem tudtál meg konkrétan az okról. A Moderációs API viszont ingyenes, gyors, és neveket viselő kategóriákat ad vissza. Ha a generálás előtt hívod meg, lehetővé teszi, hogy tisztán utasítsd vissza a kérést, elmagyarázd a felhasználónak, mi lett megjelölve, és ezt az információt megőrizd az auditáláshoz. A verify_prompt függvény kinyerje a kiváltott kategóriák listáját, a generate_safe_image pedig egyszerűen láncolja a két lépést: először ellenőrzés, aztán generálás.
from openai import OpenAI
client = OpenAI()
def verify_prompt(prompt: str) -> dict:
"""Ellenőrzi a promptot a Moderációs API-val generálás előtt."""
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):
"""Teljes folyamat: moderálás + generálás."""
# 1. lépés: előszűrés
check = verify_prompt(prompt)
if not check["allowed"]:
print(f"Prompt refused: {check['message']}")
print(f"Categories: {check['categories']}")
return None
# 2. lépés: generálás
print("Prompt validated, generating...")
return generate_with_moderation(prompt, output)
# Teszt egy ártalmatlan prompttal
generate_safe_image(
"A mountain landscape with a crystal clear lake",
"mountain.png"
)
A generált képek ellenőrzése is
Egy ártalmatlan prompt is eredményezhet nem kívánt képet. Egy kerülő megfogalmazás, egy kifejezés kétértelműsége vagy egyszerűen csak a modell szerencsétlen értelmezése is elég ahhoz, hogy olyan vizuális tartalom szülessen, amelyet nem szeretnél megjeleníteni a logód alatt. Az omni-moderation-latest modell képeket is bemenetként fogad, így bezárhatod a kört: ugyanazok a kategória-mechanizmusok vonatkoznak a generált fájlra is. Az alábbi teljes folyamat láncolja a három fázist – prompt ellenőrzés, generálás, kép ellenőrzés –, és ami kritikus fontosságú: megjelölés esetén törli a fájlt a lemezről, mielőtt visszaadná az ítéletet. Egy problémás kép, amely „vizsgálat alatt“ a szerveren marad, olyan kép, amely előbb-utóbb szivárogni fog.
from openai import OpenAI
import base64
client = OpenAI()
def moderate_generated_image(image_path: str) -> dict:
"""Elemzi a generált képet problémás tartalom észlelésére."""
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):
"""Teljes folyamat: prompt moderálás + generálás + kép moderálás."""
# 1. A prompt ellenőrzése
check_prompt = verify_prompt(prompt)
if not check_prompt["allowed"]:
return {"status": "prompt_refused", "details": check_prompt}
# 2. A kép generálása
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. A generált kép ellenőrzése
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}
Amikor a felhasználók írják a promptokat
A felhasználók által generált tartalom megváltoztatja a probléma természetét: már nem ügyetlenséggel állsz szemben, hanem időnként szándékos kijátszási kísérletekkel. A PromptModerator osztály négy különböző természetű védelmi réteget halmoz fel, ami a komoly védelem alapelve. A tisztítás eltávolítja azokat a vezérlőkaraktereket, amelyeken keresztül a befecskendezések történnek, és ötszáz karakterben maximalizálja a hosszat, ezzel elejét véve az utasítások elárasztására tervezett flood promptoknak. A helyi ellenőrzés egy tiltószó-listán keresztül – amely üresen hagyott, hogy a te szabályzatod és szektorod szerint töltsd fel – nullára csökkenti a költséget azoknál, amelyeket már eleve ismersz. Ezután a Moderációs API veszi át az irányítást minden olyan esetben, amit a listád nem előrejelzett. Végül a biztonsági előtag, amelyet a végső prompt elé fűzünk, kifejezetten emlékezteti a modellt az elvárt keretrendszerre, ezzel a határvonalat a javadra tolva el a szélsőséges esetekben.
from openai import OpenAI
import re
client = OpenAI()
class PromptModerator:
"""Többrétegű szűrő felhasználói promptokhoz."""
def __init__(self):
self.forbidden_words = [] # Töltsd fel a szabályzatod szerint
self.security_prefix = (
"Safe and appropriate image for all audiences. "
"No violent, sexual, or discriminatory content. "
)
def clean(self, prompt: str) -> str:
"""Tisztítja és normalizálja a felhasználói promptot."""
# Potenciális befecskendezések eltávolítása
prompt = prompt.strip()
# Hossz korlátozása
prompt = prompt[:500]
# Vezérlőkarakterek eltávolítása
prompt = re.sub(r'[\x00-\x1f\x7f-\x9f]', '', prompt)
return prompt
def check_words(self, prompt: str) -> bool:
"""Ellenőrzi a tiltott szavak hiányát."""
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:
"Biztonsági előtagot fűz a prompt elé."
return f"{self.security_prefix}{prompt}"
def pipeline(self, raw_prompt: str) -> dict:
"Teljes moderációs folyamat egy felhasználói prompt számára."
# 1. lépés: tisztítás
prompt = self.clean(raw_prompt)
# 2. lépés: helyi ellenőrzés
if not self.check_words(prompt):
return {"allowed": False, "reason": "Forbidden word detected"}
# 3. lépés: API moderálás
check = verify_prompt(prompt)
if not check["allowed"]:
return {"allowed": False, "reason": check["message"]}
# 4. lépés: biztonsági előtag hozzáadása
final_prompt = self.secure(prompt)
return {"allowed": True, "prompt": final_prompt}
moderator = PromptModerator()
# Felhasználói prompt szimulálása
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']}")
Naplózás az elszámoltathatóság érdekében
A nap, amikor egy problémás kép újra előkerül, a kérdés, amit feltesznek neked, ez lesz: ki kérte, mikor, és mit tett a rendszered. Naplók nélkül nincs válaszod. Az AuditLogger egy JSON sort ír minden generálásról egy .jsonl fájlba – ez egy csak-bővíthető formátum, amely támogatja az egyidejű írást, és soronként olvasható anélkül, hogy mindent be kellene tölteni a memóriába. Minden bejegyzés összekapcsol egy felhasználói azonosítót egy csonkolt prompttal, a generálás kimenetelével, és adott esetben az elutasítás okával. A report metódus ezután levezeti az elfogadási arányt az utolsó száz generálásból, és részletezi az elutasításokat: ez az a műszerfal, amely figyelmeztet, ha egy adott fiók túl sok megjelölést halmoz fel.
import json
import os
from datetime import datetime
class AuditLogger:
"Audit napló képgenerálásokhoz."
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
):
"Egy audit bejegyzést naplóz."
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):
"Jelentést generál a legutóbbi generálásokról."
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()
Szerzői jogok és védjegyek
A GPT Image képes olyan képeket előállítani, amelyek egy művész stílusát vagy egy márka vizuális identitását idézik, és ez a képesség pontosan az, ami veszélyeztet téged. A technikai moderálás ezen a téren nem véd meg: nem érzékeli, hogy egy poszter mennyire hasonlít egy versenytárséra. A védelem ezért szerződéses és szervezeti jellegű, írásos, betartatható használati szabályzat formájában, amelyet a felhasználóid elfogadnak, és a csapatod alkalmaz. A PRODUCTION_RULES blokk a minimális megfogalmazást adja, amelyet dokumentációdban és felhasználási feltételeidben is meg kell jelenítened.
# Legjobb gyakorlatok, amelyeket integrálnod kell a használati szabályzatodba
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():
"Megjeleníti a gyártási használati szabályokat."
print("=" * 60)
print("PRODUCTION RULES — AI Image Generation")
print("=" * 60)
print(PRODUCTION_RULES)
GDPR megfelelés
Egy európai vállalat számára a megőrzési idők és a hozzájárulás nem konfigurációs lehetőségek, hanem kötelezettségek, amelyek teljesítését igazolhatónak kell lennie. Ha ezeket egy explicit konfigurációs objektumban rögzíted, ahelyett, hogy szétszórnád a kódban, egyetlen helyed lesz, amit auditálás során megmutathatsz. A ComplianceConfig így egy évre állítja be a naplók megőrzését, kilencven napra a képekét, és kötelezővé teszi az AI-megjelölést és a hozzájárulást. Az add_ai_metadata metódus külön figyelmet érdemel: közvetlenül a PNG fájlba ír a PngInfo segítségével, rögzítve, hogy a kép generált, melyik eszköz készítette, és mikor. Ezek a metaadatok a fájllal utaznak, még a platformodon kívülre is, amit egyetlen weboldalon megjelenített figyelmeztetés sem képes biztosítani.
class ComplianceConfig:
"Megfelelőségi konfiguráció képgeneráláshoz."
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:
"Ellenőrzi, hogy a felhasználó hozzájárult-e az AI generáláshoz."
# Implementáld a saját hozzájárulás-kezelő rendszereddel
return True
def add_ai_metadata(self, image_path: str):
"Metaadatokat ad hozzá, jelezve az AI generálást."
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}")
Mielőtt elindítanád a rendszert
Nyolc rendelkezésnek kell helyén lennie azon a napon, amikor a rendszered hozzáférhetővé válik, és őszintébb, ha ezeket előbb kéred, mint utóbb. Először a moderálás, két fázisban: a promptok előszűrése és a képek utólagos ellenőrzése, ahogy azt a secure_pipeline is teszi. Ezután a naplózás, teljes körűen, összekapcsolva minden generálást a promptjával, szerzőjével és kimenetelével – ez az egyetlen bizonyítékod vitás esetekben, és függetlenül kell tárolni maguktól a képektől, különben egy tárolóritkítás magával sodorná a nyomonkövethetőségedet is.
Ezután jön a felhasználói oldal. A fiókonkénti sebességkorlátozás megakadályozza, hogy egyetlen előfizető egy éjszaka alatt elköltse a havi költségkeretedet, akár szándékosan, akár egy rosszul megírt script miatt. A képek generált jellegére vonatkozó tájékoztatás mind az tisztességes bánásmódhoz, mind pedig egyre inkább szabályozási követelményhez kapcsolódik; ezt kiegészíti a technikai megjelölés a fájl PNG vagy EXIF metaadataiban. A törléshez való jog feltételezi, hogy egyszerű kérésre meg tudod találni és törölni tudod egy felhasználó összes adatát, ami csak akkor lehetséges, ha az audit bejegyzéseid tartalmaznak egy user_id-t. Végül nyiss egy jelentési csatornát: a felhasználóid mindig hamarabb látják majd, mi problémás, mint te, és ha elveszed tőlük a lehetőséget, hogy szóljanak, a probléma attól még nem tűnik el.
Most állítsd össze az egészet egyetlen képgeneráló szolgáltatássá: promptok előszűrése a Moderációs API-val és egy tiltószó-listával, biztonsági előtag, az előállított kép utólagos ellenőrzése, audit napló és AI metaadatok minden egyes fájlon. Teszteld öt változatos prompttal, amelyek közül legalább egyet el kell utasítania – csak így ellenőrizheted, hogy a biztonsági korlátaid valóban működnek, és nem csupán jelen vannak a kódban.
Teszteld a tudásod!
Vizuális generálás API-n keresztül: validáld a reflexeidet élesítés előtt.
1. Mire alkalmas az inpainting és az outpainting?
Válasz: Az inpainting egy meglévő kép meghatározott területét módosítja (csere, javítás); az outpainting kiterjeszti a képet az eredeti keretén túl – két célzott szerkesztés anélkül, hogy mindent újra kellene generálni.
2. Mitől jó egy haladó vizuális prompt?
Válasz: Írd le a tárgyat, a kompozíciót, a világítást és a perspektívát – ne csak a témát: minél inkább operatőrként keretezi be a jelenetet a prompt, annál jobban engedelmeskedik a kép.
3. Hogyan dolgozz hatékonyan iterációkban?
Válasz: Kezdj egy alapgenerálással, majd kérj célzott variációkat (stílus, keretezés, részlet), ahelyett, hogy nulláról írnád újra a promptot – tartsd meg, ami működik, csak a különbséget hangold.
4. Milyen eszközökkel optimalizálhatod a generálási költségeket?
Válasz: Igazítsd a minőséget és a felbontást a valós igényhez (tervek alacsony, véglegesek magas minőségben), csökkentsd az iterációk számát jobb promptokkal, és gyorsítótárazd/használd újra az ellenőrzött vizuális elemeket.
5. Miért elengedhetetlen a vizuális tartalmak moderálása?
Válasz: Mert az API és a felhasználási feltételeid korlátokat szabnak (tiltott tartalom, valós emberek, márkák): a promptok szűrése és a kimenetek ellenőrzése megvédi a felhasználóidat és az alkalmazásodat.
Keretezz, iterálj, urald a költségeket és a megfelelést: a vizuális produkció egy folyamat – nem szerencsejáték.