Moderovanie obsahu vo veľkom meradle
Na tejto strane
Lekcia aktualizovaná 3. novembra 2026 na základe dokumentácie OpenAI: parametre
temperatureatop_psú akceptované len pri úsilí o logické uvažovanie (reasoning effort) nastavenom nanone, zatiaľ čo modely GPT-5.6 štandardne uvažujú (medium). Volania, ktoré nastavujú tieto parametre, preto musia špecifikovaťreasoning={"effort": "none"}(Responses API) aleboreasoning_effort="none"(Chat Completions). Zdroje: Using GPT-6 · GPT-5.6 Terra.
Ochrana používateľov v produkcii
Akonáhle je tvoja aplikácia spustená, musíš riešiť nevhodný obsah – či už na vstupe (škodlivé prompty) alebo na výstupe (problematické odpovede). Táto obojsmerná požiadavka často tímy zaskočí. Väčšina ľudí najprv myslí na filtrovanie toho, čo posielajú používatelia, ale reputačné riziko sa sústreďuje na to, čo tvoja aplikácia publikuje pod tvojím menom. Dobre zosúladený model zriedka generuje šokujúci obsah sám od seba, ale môže tak urobiť, keď je do toho tlačený – a tvoja značka sa objaví v hornej časti screenshotu.
Prejdeme od jedného volania API k vysokopriepustnému asynchrónnemu pipeline a budeme postupne zvyšovať mierku.
Prvá vrstva: API pre moderovanie
API pre moderovanie (Moderations API) klasifikuje text do niekoľkých rizikových kategórií a vracia binárny verdikt aj podrobné skóre. Je rýchle a bezplatné, čo z neho robí prirodzený prvý filter pre akúkoľvek verejnú aplikáciu. Funkcia nižšie zobrazuje iba kategórie so skóre nad 0,3 – čo je zámerne nízky prah. V tejto fáze chceš vidieť, čo sa blíži k hranici, nielen to, čo ju prekročilo.
import openai
client = openai.OpenAI()
def moderate_content(text: str) -> dict:
"""Skontroluje, či 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
},
}
# Príklad
result = moderate_content("How do I bake a chocolate cake?")
print(f"Flagged: {result['flagged']}")
V produkcii binárny verdikt nestačí. V závislosti od obsahu a kontextu môžeš chcieť povoliť ho, prepísať, zablokovať alebo eskalovať na človeka – štyri odlišné rozhodnutia, ktoré by si mal v kóde explicitne pomenovať, namiesto improvizácie s booleovskými hodnotami. Nasledujúci pipeline formalizuje tieto akcie, aplikuje prahy pre jednotlivé kategórie a pridáva druhú vrstvu na detekciu vstrekovania promptov (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:
"""Viacvrstvový pipeline na moderovanie."""
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:
"""Moderovanie vstupného obsahu (prompt používateľa)."""
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)}",
)
# Detekcia vstrekovania promptu
if self._detect_injection(text):
return ModerationResult(
action=ModerationAction.BLOCK,
reason="Zistený pokus o vstrekovanie promptu",
)
return ModerationResult(action=ModerationAction.ALLOW)
def moderate_output(self, response: str) -> ModerationResult:
"""Moderovanie výstupného obsahu (odpoveď LLM)."""
moderation = client.moderations.create(
model="omni-moderation-latest",
input=response,
)
if moderation.results[0].flagged:
return ModerationResult(
action=ModerationAction.BLOCK,
reason="Generovaná odpoveď obsahuje nevhodný obsah",
)
return ModerationResult(action=ModerationAction.ALLOW)
def _detect_injection(self, text: str) -> bool:
"""Detekcia pokusov o vstrekovanie promptu."""
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)
Prah 0,5 pre self-harm – prísnejší ako 0,7 používaný pre ostatné kategórie – ilustruje úvahu, ktorú by si mal aplikovať na každý prah. Tu sú náklady na falošne pozitívny výsledok zďaleka nie také vysoké ako náklady na falošne negatívny výsledok, takže znižuješ laťku. Tento kompromis rob kategóriu po kategórii na základe tvojej cieľovej skupiny, namiesto aplikovania jednotnej hodnoty.
Detekcia vstrekovania založená na kľúčových slovách má svoje obmedzenia. Zachytí naivné pokusy, ktoré tvoria väčšinu objemu, a nič viac: mierne odlišné formulácie alebo preložené verzie prejdú cez sieť. Ber to ako filter šumu, nie ako obranu. Skutočná ochrana proti vstrekovaniu je architektonická – nikdy nedávaj modelu schopnosti, ktoré by mohol zneužiť prevzatý prompt.
Zvládanie záťaže
Vo vysoko frekventovanej aplikácii sa synchronné moderovanie stáva úzkym hrdlom: každá správa čaká na svoj verdikt pred ďalším spracovaním. Asynchrónny moderátor tieto kroky oddelí tým, že zaradí obsah do fronty na spracovanie viacerými pracovníkmi a zároveň priebežne sleduje užitočné štatistiky.
import asyncio
class AsyncModerator:
"""Asynchrónne moderovanie obsahu pre vysokú priepustnosť."""
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 "Žiadny obsah nebol moderovaný."
return (
f"Celkom: {total} | "
f"Povolené: {self.stats['allowed']} ({self.stats['allowed']/total:.1%}) | "
f"Blokované: {self.stats['blocked']} ({self.stats['blocked']/total:.1%})"
)
Miera blokovania produkovaná funkciou report je tvojím hlavným kalibračným ukazovateľom. Ak náhle vyskočí na 15 % po tom, čo bežala na 0,5 %, existujú len dve vysvetlenia: si pod koordinovaným útokom, alebo si práve pokazil svoje prahy. V oboch prípadoch to chceš vedieť do hodiny, nie až pri ďalšej mesačnej revízii.
Treba spomenúť ešte jedno obmedzenie: API pre moderovanie nič nevie o tvojom biznise. Správa, ktorá je všeobecne úplne prijateľná, môže porušovať tvoje vlastné pravidlá – žiadosť o lekársku radu od bankového asistenta, snaha získať cenu mimo štandardnej ponuky alebo obídenie postupu. Kontextové moderovanie pridáva túto vrstvu odoslaním správy modelu s tvojimi explicitnými pravidlami, ale až potom, čo ju štandardný filter povolil.
def contextual_moderation(
text: str,
app_context: str,
business_rules: list[str],
) -> ModerationResult:
"""Kontextovo závislé moderovanie šité na mieru aplikácii."""
pipeline = ModerationPipeline()
standard_result = pipeline.moderate_input(text)
if standard_result.action == ModerationAction.BLOCK:
return standard_result
verification_prompt = (
f"Kontext aplikácie: {app_context}\n\n"
f"Obchodné pravidlá na overenie:\n"
+ "\n".join(f"- {r}" for r in business_rules)
+ f"\n\nSpráva používateľa: {text}\n\n"
"Dodržiava správa všetky pravidlá? "
"Odpovedz áno alebo nie s krátkym odôvodnení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)
Poradie týchto dvoch kontrol je dôležité. Bezplatný, rýchly filter beží ako prvý a volanie plateného modelu sa uskutoční len pre správy, ktoré ním prešli. Pri reálnej premávke to pokrýva takmer všetky správy. Urobiť to naopak – platiť za volanie modelu pre obsah, ktorý by API pre moderovanie zamietlo za milisekundy – by bolo plytvanie.
Uchovávanie obhájiteľného záznamu
Rozhodnutie o moderovaní je rozhodnutie, za ktoré budeš tak či onak zodpovedný. Potrebuješ log – ale taký, ktorý sa sám nestane problémom. Komentár v kóde zvýrazňuje najdôležitejší riadok v súbore: zaznamenaj akciu, dôvod a dĺžku, nikdy nie surový text. Ukladanie správ používateľov do logovacieho súboru ťa vystavuje povinnostiam ochrany údajov, ktoré sú oveľa ťažšie než poskytovaná služba.
import json
import time
from pathlib import Path
class ModerationLog:
"""Logovanie všetkých rozhodnutí o moderovaní na úč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 surový text kvôli súkromiu
}
with open(self.path, "a") as f:
f.write(json.dumps(entry) + "\n")
Ak stále potrebuješ byť schopný retrieveovať konkrétnu správu počas sporu, zaloguj hash textu namiesto samotného textu. To ti umožní potvrdiť, že daný kus obsahu zodpovedá zaznamenanému rozhodnutiu, bez toho, aby si obsah u seba uchovával.
Kľúčové poznatky
- Moderuj vstupy (prompty) aj výstupy (odpovede)
- Použi API pre moderovanie ako svoju prvú, rýchlu a bezplatnú vrstvu
- Upravuj prahy kategóriu po kategórii na základe reálnych nákladov falošne negatívneho výsledku
- Pridaj detekciu vstrekovania s vedomím, že zachytí len naivné pokusy
- Loguj všetky rozhodnutia na účely auditu bez ukladania surového obsahu