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

Tartalommoderálás nagy léptékben

19. lecke 20 közül Frissítve 2026. november 3. Haladó
Ezen az oldalon
  1. Felhasználóid védelme éles környezetben
  2. Az első réteg: a Moderations API
  3. Terhelés kezelése
  4. Védhető napló vezetése
  5. Főbb megállapítások

Lecke frissítve: 2026. november 3. az OpenAI dokumentációja alapján: a temperature és a top_p paraméterek csak none gondolkodási erőfeszítés (reasoning effort) mellett fogadhatók el, míg a GPT-5.6 modellek alapértelmezetten (medium) gondolkodnak. Az ezeket a paramétereket beállító hívásoknak ezért meg kell adniuk a reasoning={"effort": "none"} (Responses API) vagy reasoning_effort="none" (Chat Completions) beállítást. Források: GPT-6 használata · GPT-5.6 Terra.

Felhasználóid védelme éles környezetben

Amint az alkalmazásod élesbe kerül, kezelned kell a nem megfelelő tartalmakat – mind a bemenetnél (rosszindulatú promptok), mind a kimenetnél (problémás válaszok). Ezt a kétirányú követelményt sok csapat figyelmen kívül hagyja. A legtöbben először a felhasználók által küldött adatok szűrésére gondolnak, pedig a hírnévkockázat főként abban rejlik, amit az alkalmazásod a te nevedben tesz közzé. Egy jól igazított modell ritkán generál sokkoló tartalmat magától, de ha nyomás alá helyezik, képes rá – és a márkád neve lesz a képernyőfotó tetején.

Lépésről lépésre haladunk: egyetlen API-hívástól indulunk el egy nagy átviteli sebességű, aszinkron folyamatrendszer felé.

Az első réteg: a Moderations API

A Moderations API több kockázati kategória szerint osztályozza a szöveget, és egyszerre ad vissza bináris döntést és részletes pontszámokat. Gyors és ingyenes, így bármely nyilvános alkalmazás természetes első szűrője. Az alábbi függvény csak azokat a kategóriákat emeli ki, amelyek pontszáma meghaladja a 0,3-at – ez szándékosan alacsony küszöb. Ebben a szakaszban nemcsak azt akarod látni, ami átlépi a határt, hanem azt is, ami közelít hozzá.

import openai

client = openai.OpenAI()

def moderate_content(text: str) -> dict:
    """Ellenőrzi, hogy a szöveg tartalmaz-e nem megfelelő tartalmat."""
    response = client.moderations.create(
        model="omni-moderation-latest",
        input=text,
    )

    result = response.results[0]
    return {
        "flagged": result.flagged,
        "categories": {
            cat: score
            for cat, score in result.category_scores.__dict__.items()
            if score > 0.3
        },
    }

# Példa
result = moderate_content("How do I bake a chocolate cake?")
print(f"Flagged: {result['flagged']}")

Éles környezetben a bináris döntés önmagában nem elég. A tartalomtól és a kontextustól függően engedélyezned kell azt, át kell írnod, blokkolnod, vagy emberi ellenőrzésre kell escalálnod – ez négy különálló döntés, amelyet explicit módon kell elnevezned a kódban, nem pedig boole változókkal improvizálni. Az alábbi folyamatrendszer formalizálja ezeket a műveleteket, kategóriánkénti küszöbértékeket alkalmaz, és hozzáad egy második réteget a prompt-injekciók észlelésére.

from enum import Enum
from dataclasses import dataclass

class ModerationAction(Enum):
    ALLOW = "allow"
    MODIFY = "modify"
    BLOCK = "block"
    ESCALATE = "escalate"

@dataclass
class ModerationResult:
    action: ModerationAction
    reason: str | None = None
    modified_content: str | None = None

class ModerationPipeline:
    """Többrétegű moderálási folyamatrendszer."""

    def __init__(self, thresholds: dict | None = None):
        self.thresholds = thresholds or {
            "harassment": 0.7,
            "hate": 0.7,
            "self-harm": 0.5,
            "sexual": 0.7,
            "violence": 0.7,
        }

    def moderate_input(self, text: str) -> ModerationResult:
        """Bemeneti tartalom (felhasználói prompt) moderálása."""
        moderation = client.moderations.create(
            model="omni-moderation-latest",
            input=text,
        )

        result = moderation.results[0]
        if result.flagged:
            problematic_categories = [
                cat for cat, flagged in result.categories.__dict__.items()
                if flagged
            ]
            return ModerationResult(
                action=ModerationAction.BLOCK,
                reason=f"Nem megfelelő tartalom: {', '.join(problematic_categories)}",
            )

        # Prompt-injekció észlelése
        if self._detect_injection(text):
            return ModerationResult(
                action=ModerationAction.BLOCK,
                reason="Prompt-injekciós kísérlet észlelve",
            )

        return ModerationResult(action=ModerationAction.ALLOW)

    def moderate_output(self, response: str) -> ModerationResult:
        """Kimeneti tartalom (LLM-válasz) moderálása."""
        moderation = client.moderations.create(
            model="omni-moderation-latest",
            input=response,
        )

        if moderation.results[0].flagged:
            return ModerationResult(
                action=ModerationAction.BLOCK,
                reason="A generált válasz nem megfelelő tartalmat tartalmaz",
            )

        return ModerationResult(action=ModerationAction.ALLOW)

    def _detect_injection(self, text: str) -> bool:
        """Prompt-injekciós kísérletek észlelése."""
        markers = [
            "ignore previous instructions",
            "ignore your instructions",
            "forget your guidelines",
            "you are now",
            "new role",
            "system prompt",
            "jailbreak",
        ]
        text_lower = text.lower()
        return any(m in text_lower for m in markers)

A self-harm kategóriára vonatkozó 0,5-ös küszöb – amely szigorúbb, mint a többi kategóriára alkalmazott 0,7 – jól szemlélteti azt a logikát, amelyet minden küszöbértéknél alkalmaznod kell. Itt a hamis pozitív döntés költsége messze elmarad a hamis negatív döntés költségétől, ezért lejjebb viszed a lécet. Ezt a kompromisszumot kategóriánként, a saját közönséged alapján kell meghoznod, nem pedig egységes értéket alkalmazni.

A jelölőalapú injekcióészlelésnek van egy szépséghibája. Csak a naiv kísérleteket fogja el, amelyek a forgalom nagy részét teszik ki, de semmi mást: egy kissé eltérő megfogalmazás vagy egy lefordított változat átszökik a rostán. Tekints rá zajszűrőként, nem pedig védelemként. Az injekciók elleni valódi védelem architektúrális kérdés – soha ne adj a modellnek olyan képességeket, amelyeket egy eltérített prompt kihasználhatna.

Terhelés kezelése

Nagy forgalmú alkalmazásoknál a szinkron moderálás szűk keresztmetszetté válik: minden üzenet vár a döntésre, mielőtt feldolgoznák. Egy aszinkron moderátor szétválasztja ezeket a lépéseket: a tartalmat sorba állítja, hogy több munkafolyamat (worker) fogyaszthassa, miközben hasznos statisztikákat is gyűjt menet közben.

import asyncio

class AsyncModerator:
    """Tartalom aszinkron moderálása nagy átviteli sebesség érdekében."""

    def __init__(self, num_workers: int = 10):
        self.pipeline = ModerationPipeline()
        self.queue: asyncio.Queue = asyncio.Queue()
        self.num_workers = num_workers
        self.stats = {"allowed": 0, "blocked": 0, "escalated": 0}

    async def worker(self):
        while True:
            task = await self.queue.get()
            try:
                result = self.pipeline.moderate_input(task["text"])
                task["callback"](result)

                match result.action:
                    case ModerationAction.ALLOW:
                        self.stats["allowed"] += 1
                    case ModerationAction.BLOCK:
                        self.stats["blocked"] += 1
                    case ModerationAction.ESCALATE:
                        self.stats["escalated"] += 1
            finally:
                self.queue.task_done()

    async def start(self):
        for _ in range(self.num_workers):
            asyncio.create_task(self.worker())

    def report(self) -> str:
        total = sum(self.stats.values())
        if total == 0:
            return "Nem történt tartalommoderálás."
        return (
            f"Összesen: {total} | "
            f"Engedélyezve: {self.stats['allowed']} ({self.stats['allowed']/total:.1%}) | "
            f"Blokkolva: {self.stats['blocked']} ({self.stats['blocked']/total:.1%})"
        )

A report által előállított blokkolási arány az elsődleges kalibrációs metrikád. Ha hirtelen 0,5%-ról 15%-ra ugrik, csak két magyarázat lehetséges: koordinált támadás alatt állsz, vagy éppen elrontottad a küszöbértékeidet. Mindkét esetben órákon belül tudnod kell róla, nem a következő havi értékelésen.

Érdemes megemlíteni egy utolsó korlátot is: a Moderations API semmit sem tud a te üzletedről. Egy üzenet, amely általánosságban teljesen elfogadható, sértheti a te saját szabályaidat – például orvosi tanácsot kér egy banki asszisztenstől, próbál off-grid árat szerezni, vagy megkerülni egy eljárást. A kontextuális moderálás ezt a réteget adja hozzá: az üzenetet elküldi egy modellnek a te explicit szabályaiddal, de csak azután, hogy a szabványos szűrő engedélyezte azt.

def contextual_moderation(
    text: str,
    app_context: str,
    business_rules: list[str],
) -> ModerationResult:
    """Az alkalmazásra szabott, kontextusfüggő moderálás."""
    pipeline = ModerationPipeline()
    standard_result = pipeline.moderate_input(text)

    if standard_result.action == ModerationAction.BLOCK:
        return standard_result

    verification_prompt = (
        f"Application context: {app_context}\n\n"
        f"Business rules to verify:\n"
        + "\n".join(f"- {r}" for r in business_rules)
        + f"\n\nUser message: {text}\n\n"
        "Does the message comply with all rules? "
        "Answer yes or no with a brief justification."
    )

    response = client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # temperature requires effort none
        input=verification_prompt,
        max_output_tokens=100,
        temperature=0.0,
    )

    if "no" in response.output_text.lower()[:10]:
        return ModerationResult(
            action=ModerationAction.BLOCK,
            reason=response.output_text,
        )

    return ModerationResult(action=ModerationAction.ALLOW)

Ennek a két ellenőrzésnek a sorrendje számít. Az ingyenes, gyors szűrő fut először, és a fizetett modellhívás csak azokon az üzeneteken történik meg, amelyek átmentek rajta. Valós forgalom esetén ez az üzenetek szinte teljes körét lefedi. Fordítva csinálni – vagyis fizetni egy modellhívásért olyan tartalom esetén, amelyet a Moderations API milliszekundumok alatt elutasított volna – pazarlás lenne.

Védhető napló vezetése

A moderálási döntés olyan döntés, amelyért előbb-utóbb felelősségre vonnak. Naplót kell vezetned – de olyat, amely maga nem válik problémává. A kódban lévő megjegyzés kiemeli a fájl legfontosabb sorát: rögzítsd a műveletet, az indoklást és a hosszúságot, soha ne a nyers szöveget. A felhasználói üzenetek naplófájlban történő tárolása olyan adatvédelmi kötelezettségeknek tesz ki, amelyek sokkal súlyosabbak, mint maga a nyújtott szolgáltatás.

import json
import time
from pathlib import Path

class ModerationLog:
    """Minden moderálási döntés naplózása auditálási céllal."""

    def __init__(self, log_path: str = "logs/moderation.jsonl"):
        self.path = Path(log_path)
        self.path.parent.mkdir(parents=True, exist_ok=True)

    def record(
        self,
        text: str,
        result: ModerationResult,
        source: str = "input",
    ):
        entry = {
            "timestamp": time.time(),
            "source": source,
            "action": result.action.value,
            "reason": result.reason,
            "text_length": len(text),
            # DO NOT log raw text for privacy
        }

        with open(self.path, "a") as f:
            f.write(json.dumps(entry) + "\n")

Ha mégis szükség van arra, hogy vita esetén egy adott üzenetet vissza tudj keresni, akkor a szöveg hash-értékét naplózd a szöveg helyett. Ez lehetővé teszi, hogy megerősítsd: egy adott tartalom megegyezik egy rögzített döntéssel, anélkül, hogy magát a tartalmat megtartanád a saját oldaladon.

Főbb megállapítások

  • Moderáld mind a bemeneteket (promptok), mind a kimeneteket (válaszok)
  • Használd a Moderations API-t első, gyors és ingyenes rétegként
  • Állítsd be a küszöbértékeket kategóriánként a hamis negatív döntés valós költsége alapján
  • Adj hozzá injekcióészlelést, tudva, hogy csak a naiv kísérleteket fogja el
  • Naplózz minden döntést auditálás céljából, nyers tartalom tárolása nélkül