Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Moderálás és vizuális tartalmak biztonsága

12. lecke 12 közül Frissítve 2026. november 3. Fejlesztő
Ezen az oldalon
  1. Moderálás és vizuális tartalmak biztonsága
  2. A beépített moderációs rendszer
  3. Promptok előszűrése
  4. A generált képek ellenőrzése is
  5. Amikor a felhasználók írják a promptokat
  6. Naplózás az elszámoltathatóság érdekében
  7. Szerzői jogok és védjegyek
  8. GDPR megfelelés
  9. Mielőtt elindítanád a rendszert
  10. Teszteld a tudásod!

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ális moderation_details objektummal, nem pedig a hibaüzenetben szereplő safety vagy content_policy szavak jelenléte alapján; hozzáadtuk a moderation paramé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, a gpt-image-1.5, gpt-image-1-mini és chatgpt-image-latest modellek pedig 2026. december 1-jén kerülnek kivonásra. A példák most a gpt-image-2.5-sunburst modellt használják, amely a legpontosabb szerkesztéshez; a gpt-image-2.5-flare gyorsabb az általános generáláshoz. Mindkettő elfogadja az xhigh és max minőségeket is. A GPT Image modellek mindig base64 formátumban adják vissza a képet: a régebbi DALL·E modellekből ismert response_format paramé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.