Moderiranje vsebine v velikem obsegu
Na tej strani
Lekcija posodobljena 3. novembra 2026 na podlagi dokumentacije OpenAI: parametra
temperatureintop_psta sprejeta le pri naporu razmišljanja (reasoning effort) vrednostinone, medtem ko modeli GPT-5.6 privzeto razmišljajo (medium). Klici, ki nastavljajo te parametre, morajo zato določitireasoning={"effort": "none"}(Responses API) alireasoning_effort="none"(Chat Completions). Viri: Uporaba GPT-6 · GPT-5.6 Terra.
Zaščita uporabnikov v proizvodnem okolju
Takoj ko tvoja aplikacija zaživi, se moraš spopasti z neustrezno vsebino – tako na vhodu (zlonamerni pozivi) kot na izhodu (problematični odgovori). Ta dvostranska zahteva pogosto preseneti ekipe. Večina ljudi najprej pomisli na filtriranje tega, kar pošiljajo uporabniki, vendar je tveganje za ugled osredotočeno na to, kar tvoja aplikacija objavi v tvojem imenu. Dobro usklajen model redko sam od sebe ustvari šokantno vsebino, lahko pa to stori, ko ga pritisneš – in tvoja blagovna znamka se pojavi na vrhu posnetka zaslona.
Prešli bomo od enega samega klica API-ja do asinhronega cevovoda z visoko prepustnostjo in postopoma povečevali obseg.
Prva plast: API za moderiranje
API za moderiranje (Moderations API) razvršča besedilo v več kategorij tveganja in vrne tako binarno sodbo kot podrobne rezultate. Hiter je in brezplačen, zato je naravni prvi filter za vsako javno aplikacijo. Spodnja funkcija prikaže le kategorije z rezultati nad 0,3 – to je namerno nizka meja. Na tej stopnji želiš videti, kaj se približuje meji, ne le tistega, kar jo prečka.
import openai
client = openai.OpenAI()
def moderate_content(text: str) -> dict:
"""Preveri, ali besedilo vsebuje neustrezno vsebino."""
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
},
}
# Primer
result = moderate_content("How do I bake a chocolate cake?")
print(f"Flagged: {result['flagged']}")
V proizvodnem okolju binarna sodba ni dovolj. Glede na vsebino in kontekst jo boš morda želel dovoliti, prepisati, blokirati ali posredovati človeku – štiri različne odločitve, ki jih moraš v kodi izrecno poimenovati, namesto da bi improviziral z boolovimi vrednostmi. Spodnji cevovod formalizira ta dejanja, uporabi pragove za posamezne kategorije in doda drugo plast za zaznavanje vbrizgavanja pozivov (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:
"""Večplastni cevovod za moderiranje."""
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:
"""Moderiraj vhodno vsebino (uporabniški poziv)."""
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"Neustrezna vsebina: {', '.join(problematic_categories)}",
)
# Zaznavanje vbrizgavanja pozivov
if self._detect_injection(text):
return ModerationResult(
action=ModerationAction.BLOCK,
reason="Zaznan poskus vbrizgavanja poziva",
)
return ModerationResult(action=ModerationAction.ALLOW)
def moderate_output(self, response: str) -> ModerationResult:
"""Moderiraj izhodno vsebino (odgovor LLM)."""
moderation = client.moderations.create(
model="omni-moderation-latest",
input=response,
)
if moderation.results[0].flagged:
return ModerationResult(
action=ModerationAction.BLOCK,
reason="Ustvarjeni odgovor vsebuje neustrezno vsebino",
)
return ModerationResult(action=ModerationAction.ALLOW)
def _detect_injection(self, text: str) -> bool:
"""Zaznaj poskuse vbrizgavanja pozivov."""
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)
Prag 0,5 za self-harm – strožji od 0,7, uporabljenega za druge kategorije – ponazarja razmislek, ki ga moraš uporabiti za vsak prag. Tu strošek lažno pozitivnega rezultata nikakor ni primerljiv s stroškom lažno negativnega, zato znižaš letvico. To kompromisno odločitev sprejmi kategorijo za kategorijo, glede na tvoje občinstvo, namesto da bi uporabil enotno vrednost.
Zaznavanje vbrizgavanja na podlagi markerjev ima svojo past. Zajame naivne poskuse, ki predstavljajo večino prometa, in nič več: nekoliko drugačna formulacija ali prevedena različica se mu izmuzne. Obravnavaj ga kot filter šuma, ne kot obrambo. Prava zaščita pred vbrizgavanjem je arhitekturna – modelu nikoli ne daj zmogljivosti, ki bi jih ugrabljen poziv lahko izkoristil.
Obvladovanje obremenitve
Pri aplikaciji z velikim prometom sinhrono moderiranje postane ozko grlo: vsako sporočilo čaka na svojo sodbo, preden se obdelava. Asinhroni moderator te korake loči z vrstenjem vsebine za porabo s strani več delavcev, hkrati pa sproti sledi uporabni statistiki.
import asyncio
class AsyncModerator:
"""Asinhrono moderiranje vsebine za visoko prepustnost."""
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 "Ni moderirane vsebine."
return (
f"Skupaj: {total} | "
f"Dovoljeno: {self.stats['allowed']} ({self.stats['allowed']/total:.1%}) | "
f"Blokirano: {self.stats['blocked']} ({self.stats['blocked']/total:.1%})"
)
Stopnja blokiranja, ki jo proizvede report, je tvoja glavna kalibracijska metrika. Če nenadoma skoči na 15 %, potem ko je delovala pri 0,5 %, obstajata le dve razlagi: si pod koordiniranim napadom ali pa si pravkar pokvaril svoje pragove. V obeh primerih želiš izvedeti v roku ene ure, ne šele na naslednjem mesečnem pregledu.
Omeniti velja še eno omejitev: API za moderiranje ne ve ničesar o tvojem poslu. Sporočilo, ki je na splošno povsem sprejemljivo, lahko krši tvoja lastna pravila – zahteva po zdravniškem nasvetu bančnemu asistentu, poskus pridobitve tarife izven omrežja ali obhod postopka. Kontekstualno moderiranje doda to plast tako, da sporočilo pošlje modelu s tvojimi izrecnimi pravili, vendar šele potem, ko ga je standardni filter prepustil.
def contextual_moderation(
text: str,
app_context: str,
business_rules: list[str],
) -> ModerationResult:
"""Kontekstualno moderiranje, prilagojeno aplikaciji."""
pipeline = ModerationPipeline()
standard_result = pipeline.moderate_input(text)
if standard_result.action == ModerationAction.BLOCK:
return standard_result
verification_prompt = (
f"Kontekst aplikacije: {app_context}\n\n"
f"Poslovna pravila za preverjanje:\n"
+ "\n".join(f"- {r}" for r in business_rules)
+ f"\n\nUporabniško sporočilo: {text}\n\n"
"Ali sporočilo upošteva vsa pravila? "
"Odgovori z da ali ne in na kratko utemelji."
)
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)
Vrstni red teh dveh preverjanj je pomemben. Brezplačen, hiter filter se izvede prvi, klic plačljivega modela pa se zgodi le za sporočila, ki ga prestanejo. Pri realnem prometu to zajame skoraj vsa sporočila. Obratno ravnanje – plačevanje klica modela za vsebino, ki bi jo API za moderiranje zavrnil v milisekundah – bi bilo potratno.
Vodenje zagirljive evidence
Odločitev o moderiranju je odločitev, za katero boš tako ali drugače odgovarjal. Potrebuješ dnevnik – takšen, ki sam ne postane problem. Komentar v kodi poudarja najpomembnejšo vrstico v datoteki: zabeleži dejanje, razlog in dolžino, nikoli pa surovega besedila. Shranjevanje uporabniških sporočil v dnevniško datoteko te izpostavlja obveznostim varstva podatkov, ki so veliko težje od same ponujene storitve.
import json
import time
from pathlib import Path
class ModerationLog:
"""Zabeleži vse odločitve o moderiranju za namene revizije."""
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")
Če moraš biti še vedno zmožen pridobiti določeno sporočilo med sporom, zabeleži hash besedila namesto samega besedila. To ti omogoča, da potrdiš, da se določen kos vsebine ujema z zabeleženo odločitvijo, ne da bi vsebino hranil na svoji strani.
Ključne ugotovitve
- Moderiraj tako vhode (pozive) kot izhode (odgovore)
- Uporabi API za moderiranje kot svojo prvo, hitro in brezplačno plast
- Prilagodi pragove kategorijo za kategorijo glede na realne stroške lažno negativnega rezultata
- Dodaj zaznavanje vbrizgavanja, vedoč, da zajame le naivne poskuse
- Zabeleži vse odločitve za namene revizije, ne da bi shranjeval surovo vsebino