Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Moderování obsahu ve velkém měřítku

Lekce 19 z 20 Aktualizováno 3. listopadu 2026 Pokročilý
Na této stránce
  1. Ochrana tvých uživatelů v produkci
  2. První vrstva: API pro moderování
  3. Zvládání zátěže
  4. Uchovávání obhajitelného záznamu
  5. Klíčové poznatky

Lekce aktualizována 3. listopadu 2026 na základě dokumentace OpenAI: parametry temperature a top_p jsou přijímány pouze při úsilí o uvažování (reasoning effort) nastaveném na none, zatímco modely GPT-5.6 ve výchozím nastavení uvažují (medium). Volání, která tyto parametry nastavují, musí proto specifikovat reasoning={"effort": "none"} (Responses API) nebo reasoning_effort="none" (Chat Completions). Zdroje: Používání GPT-6 · GPT-5.6 Terra.

Ochrana tvých uživatelů v produkci

Jakmile je tvoje aplikace spuštěna, musíš řešit nevhodný obsah – jak na vstupu (záškodnické prompty), tak na výstupu (problematické odpovědi). Tento dvoustranný požadavek často týmy zaskočí. Většina lidí nejprve přemýšlí o filtrování toho, co uživatelé pošlou, ale reputační riziko se soustředí na to, co tvoje aplikace zveřejňuje pod tvým jménem. Dobře zarovnaný model jen zřídka generuje šokující obsah sám od sebe, ale může tak učinit, když je k tomu tlačen – a tvoje značka se objeví v horní části screenshotu.

Přejdeme od jediného volání API k vysoce výkonnému asynchronnímu pipeline a budeme postupně zvyšovat měřítko.

První vrstva: API pro moderování

API Moderations klasifikuje text do několika rizikových kategorií a vrací jak binární verdikt, tak podrobná skóre. Je rychlé a zdarma, což z něj dělá přirozený první filtr pro jakoukoli veřejnou aplikaci. Níže uvedená funkce zobrazuje pouze kategorie se skóre nad 0,3 – což je záměrně nízký práh. V této fázi chceš vidět, co se blíží hranici, nejen to, co ji překračuje.

import openai

client = openai.OpenAI()

def moderate_content(text: str) -> dict:
    """Zkontroluje, zda text obsahuje nevhodný obsah."""
    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říklad
result = moderate_content("Jak upeču čokoládový dort?")
print(f"Označeno: {result['flagged']}")

V produkci binární verdikt nestačí. V závislosti na obsahu a kontextu můžeš chtít obsah povolit, přepsat, zablokovat nebo eskalovat na člověka – čtyři odlišná rozhodnutí, která bys měl v kódu explicitně pojmenovat, místo abys improvizoval s booleovskými hodnotami. Následující pipeline tato akce formalizuje, aplikuje prahové hodnoty pro jednotlivé kategorie a přidává druhou vrstvu pro detekci vstřikování promptů (prompt injection).

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:
    """Vícevrstvé pipeline pro moderování."""

    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:
        """Moderování vstupního obsahu (uživatelský prompt)."""
        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"Nevhodný obsah: {', '.join(problematic_categories)}",
            )

        # Detekce vstřikování promptů
        if self._detect_injection(text):
            return ModerationResult(
                action=ModerationAction.BLOCK,
                reason="Zjištěn pokus o vstřikování promptu",
            )

        return ModerationResult(action=ModerationAction.ALLOW)

    def moderate_output(self, response: str) -> ModerationResult:
        """Moderování výstupního obsahu (odpověď LLM)."""
        moderation = client.moderations.create(
            model="omni-moderation-latest",
            input=response,
        )

        if moderation.results[0].flagged:
            return ModerationResult(
                action=ModerationAction.BLOCK,
                reason="Generovaná odpověď obsahuje nevhodný obsah",
            )

        return ModerationResult(action=ModerationAction.ALLOW)

    def _detect_injection(self, text: str) -> bool:
        """Detekce pokusů o vstřikování promptů."""
        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)

Práh 0,5 pro kategorii self-harm – přísnější než 0,7 používané pro ostatní kategorie – ilustruje úvahu, kterou bys měl aplikovat na každý práh. Zde jsou náklady na falešně pozitivní výsledek zanedbatelné ve srovnání s náklady na falešně negativní výsledek, takže laťku snižuješ. Tento kompromis dělej kategorii po kategorii na základě tvého publika, místo aplikace jednotné hodnoty.

Detekce vstřikování založená na klíčových slovech má své úskalí. Zachytí naivní pokusy, které tvoří většinu objemu, a nic víc: mírně odlišné formulace nebo přeložená verze projdou. Ber to jako filtr šumu, nikoli jako obranu. Skutečná ochrana proti vstřikování je architektonická – nikdy nedávej modelu schopnosti, které by mohl zneužít převzatý prompt.

Zvládání zátěže

U aplikace s vysokým provozem se synchronní moderování stává úzkým hrdlem: každá zpráva čeká na svůj verdikt před dalším zpracováním. Asynchronní moderátor tyto kroky oddělí frontováním obsahu ke zpracování více pracovníky a zároveň sleduje užitečné statistiky.

import asyncio

class AsyncModerator:
    """Asynchronní moderování obsahu pro vysokou propustnost."""

    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 "Žádný obsah nebyl moderován."
        return (
            f"Celkem: {total} | "
            f"Povoleno: {self.stats['allowed']} ({self.stats['allowed']/total:.1%}) | "
            f"Zablokováno: {self.stats['blocked']} ({self.stats['blocked']/total:.1%})"
        )

Míra blokování produkovaná metodou report je tvým hlavním kalibračním ukazatelem. Pokud náhle vyskočí z 0,5 % na 15 %, existují pouze dvě vysvětlení: buď čelíš koordinovanému útoku, nebo jsi právě rozbil své prahové hodnoty. V obou případech se to chceš dozvědět do hodiny, ne až při příští měsíční revizi.

Je třeba zmínit ještě jedno omezení: API Moderations nic neví o tvém byznysu. Zpráva, která je obecně zcela přijatelná, může porušovat tvá vlastní pravidla – žádost o lékařskou radu od bankovního asistenta, snaha získat cenu mimo síť nebo obejití procedury. Kontextové moderování přidává tuto vrstvu odesláním zprávy modelu s tvými explicitními pravidly, ale až poté, co ji standardní filtr propustil.

def contextual_moderation(
    text: str,
    app_context: str,
    business_rules: list[str],
) -> ModerationResult:
    """Kontextově závislé moderování šité na míru aplikaci."""
    pipeline = ModerationPipeline()
    standard_result = pipeline.moderate_input(text)

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

    verification_prompt = (
        f"Kontext aplikace: {app_context}\n\n"
        f"Obchodní pravidla k ověření:\n"
        + "\n".join(f"- {r}" for r in business_rules)
        + f"\n\nZpráva uživatele: {text}\n\n"
        "Splňuje zpráva všechna pravidla? "
        "Odpověz ano nebo ne s krátkým zdůvodněním."
    )

    response = client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # temperature vyžaduje 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)

Pořadí těchto dvou kontrol je zásadní. Nejprve běží rychlý a bezplatný filtr a volání placeného modelu probíhá pouze pro zprávy, které jím projdou. Při reálném provozu to pokrývá téměř všechny zprávy. Dělat to obráceně – platit za volání modelu u obsahu, který by API Moderations zamítlo během milisekund – by bylo plýtvání.

Uchovávání obhajitelného záznamu

Rozhodnutí o moderování je rozhodnutí, za které budeš tak či onak odpovědný. Potřebuješ log – ale takový, který se sám nestane problémem. Komentář v kódu zvýrazňuje nejdůležitější řádek v souboru: zaznamenej akci, důvod a délku, nikdy ne raw text. Ukládání uživatelských zpráv do logovacího souboru tě vystavuje povinnostem ochrany údajů, které jsou mnohem těžší než poskytovaná služba.

import json
import time
from pathlib import Path

class ModerationLog:
    """Logování všech rozhodnutí o moderování pro účely auditu."""

    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),
            # NELOGUJ raw text kvůli soukromí
        }

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

Pokud musíš být stále schopen během sporu získat konkrétní zprávu, zaloguj hash textu místo samotného textu. To ti umožní potvrdit, že daný kus obsahu odpovídá zaznamenanému rozhodnutí, aniž bys obsah uchovával na své straně.

Klíčové poznatky

  • Moderuj jak vstupy (prompty), tak výstupy (odpovědi)
  • Použij API Moderations jako svou první, rychlou a bezplatnou vrstvu
  • Upravuj prahové hodnoty kategorii po kategorii na základě skutečných nákladů na falešně negativní výsledek
  • Přidej detekci vstřikování s vědomím, že zachytí pouze naivní pokusy
  • Loguj všechna rozhodnutí pro audit bez ukládání raw obsahu