Turinio moderavimas dideliu mastu
Šiame puslapyje
Pamoka atnaujinta 2026 m. lapkričio 3 d. remiantis „OpenAI“ dokumentacija: parametrai
temperatureirtop_ppriimami tik esantnonelygio samprotavimui, tuo tarpu GPT-5.6 modeliai pagal nutylėjimą samprotauja (medium). Todėl kvietimuose, kuriuose nustatomi šie parametrai, būtina nurodytireasoning={"effort": "none"}(Responses API) arbareasoning_effort="none"(Chat Completions). Šaltiniai: Using GPT-6 · GPT-5.6 Terra.
Vartotojų apsauga veiklos aplinkoje
Kai tik tavo programa pradeda veikti, privalai tvarkyti netinkamą turinį – tiek įvestyje (piktavališkos užklausos), tiek išvestyje (problemiški atsakymai). Šis dvikryptis reikalavimas dažnai nustebina komandas. Dauguma pirmiausia galvoja apie vartotojų siunčiamo turinio filtravimą, tačiau reputacinė rizika koncentruojasi ties tuo, ką tavo programa skelbia tavo vardu. Gerai suderintas modelis retai pats sugeneruoja šokiruojantį turinį, tačiau tai gali nutikti, jei jis yra spaudžiamas – o tavo prekės ženklas atsidurs ekrano kopijos viršuje.
Pereisime nuo vieno API užklausos prie didelės spartos asinchroninės duomenų srauto valdymo sistemos, palaipsniui didindami mastą.
Pirmasis sluoksnis: „Moderations“ API
„Moderations“ API klasifikuoja tekstą pagal kelias rizikos kategorijas ir grąžina tiek binarinį verdiktą, tiek išsamius balus. Jis veikia greitai ir nemokamai, todėl yra natūralus pirmasis filtras bet kuriai viešai programai. Toliau pateikta funkcija rodo tik tas kategorijas, kurių balas viršija 0,3 – tai sąmoningai žema riba. Šiame etape nori matyti, kas artėja prie ribos, o ne tik tai, kas ją peržengia.
import openai
client = openai.OpenAI()
def moderate_content(text: str) -> dict:
"""Patikrina, ar tekste yra netinkamo turinio."""
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
},
}
# Pavyzdys
result = moderate_content("How do I bake a chocolate cake?")
print(f"Flagged: {result['flagged']}")
Veiklos aplinkoje vien binarinio verdikto nepakanka. Priklausomai nuo turinio ir konteksto, gali norėti jį leisti, perrašyti, blokuoti arba perduoti žmogui – tai keturi skirtingi sprendimai, kuriuos kode turėtum įvardyti aiškiai, o ne improvizuoti naudodamas loginius kintamuosius. Toliau pateikta sistema formalizuoja šiuos veiksmus, taiko slenkstines vertes kiekvienai kategorijai ir prideda antrąjį sluoksnį užklausų injekcijų aptikimui.
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:
"""Daugiasluoksnė moderavimo sistema."""
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:
"""Moderuoja įvesties turinį (vartotojo užklausą)."""
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"Inappropriate content: {', '.join(problematic_categories)}",
)
# Užklausų injekcijų aptikimas
if self._detect_injection(text):
return ModerationResult(
action=ModerationAction.BLOCK,
reason="Prompt injection attempt detected",
)
return ModerationResult(action=ModerationAction.ALLOW)
def moderate_output(self, response: str) -> ModerationResult:
"""Moderuoja išvesties turinį (LLM atsakymą)."""
moderation = client.moderations.create(
model="omni-moderation-latest",
input=response,
)
if moderation.results[0].flagged:
return ModerationResult(
action=ModerationAction.BLOCK,
reason="Generated response contains inappropriate content",
)
return ModerationResult(action=ModerationAction.ALLOW)
def _detect_injection(self, text: str) -> bool:
"""Aptinka užklausų injekcijų bandymus."""
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)
Slenkstinė vertė 0,5 kategorijai self-harm – griežtesnė nei 0,7, naudojama kitoms kategorijoms – iliustruoja samprotavimą, kurį turėtum taikyti kiekvienai slenkstinei vertei. Čia klaidingai teigiamo rezultato kaina nė iš tolo neprilygsta klaidingai neigiamo rezultato kainai, todėl nuleidi kartelę. Šį kompromisą priimk kategorija po kategorijos, atsižvelgdamas į savo auditoriją, o ne taikydamas vienodą vertę visiems.
Žymenimis pagrįstas injekcijų aptikimas turi savo trūkumų. Jis pagauna naivius bandymus, kurie sudaro didžiąją dalį srauto, ir nieko daugiau: šiek tiek kitokia formuluotė arba išversta versija praslys pro šalį. Laikyk tai triukšmo filtru, o ne gynyba. Tikra apsauga nuo injekcijų yra architektūrinė – niekada nesuteik modeliui galimybių, kuriomis galėtų pasinaudoti perimta užklausa.
Apkrovos valdymas
Didelio srauto programoje sinchroninis moderavimas tampa „butelio kakleliu“: kiekvienas pranešimas laukia verdikto prieš tęsiant apdorojimą. Asinchroninis moderatorius atskiria šiuos veiksmus, eilėje išdėstydamas turinį, kad jį apdorotų keli darbuotojai, kartu stebėdamas naudingą statistiką.
import asyncio
class AsyncModerator:
"""Asinchroniškai moderuoja turinį dideliam pralaidumui užtikrinti."""
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 "No content moderated."
return (
f"Total: {total} | "
f"Allowed: {self.stats['allowed']} ({self.stats['allowed']/total:.1%}) | "
f"Blocked: {self.stats['blocked']} ({self.stats['blocked']/total:.1%})"
)
Funkcijos report generuojamas blokavimo rodiklis yra tavo pagrindinis kalibravimo metrikas. Jei jis staiga šokteli iki 15 %, kai anksčiau buvo 0,5 %, egzistuoja tik du paaiškinimai: esi puolamas koordinuotai arba tiesiog sugadinai savo slenkstines vertes. Bet kuriuo atveju nori apie tai sužinoti per valandą, o ne per kitą mėnesinę peržiūrą.
Verta paminėti dar vieną apribojimą: „Moderations“ API nieko nežino apie tavo verslą. Pranešimas, kuris bendrai paėmus yra priimtinas, gali pažeisti tavo pačių taisykles – pavyzdžiui, prašymas suteikti medicininę konsultaciją bankininkystės asistentui, bandymas gauti neoficialų tarifą arba apeiti procedūrą. Kontekstinis moderavimas prideda šį sluoksnį, siųsdamas pranešimą modeliui su tavo aiškiomis taisyklėmis, bet tik tada, kai standartinis filtras jį praleido.
def contextual_moderation(
text: str,
app_context: str,
business_rules: list[str],
) -> ModerationResult:
"""Kontekstui pritaikytas moderavimas, sukurtas specialiai programai."""
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)
Šių dviejų patikrų eiliškumas yra svarbus. Pirmiausia veikia nemokamas, greitas filtras, o mokamas modelio užklausos vykdymas įvyksta tik tiems pranešimams, kurie jį praėjo. Esant realiam srautui, tai apima beveik visus pranešimus. Daryti atvirkščiai – mokėti už modelio užklausą turiniui, kurį „Moderations“ API būtų atmetęs per milisekundes, būtų švaistymas.
Patikimos istorijos išsaugojimas
Moderavimo sprendimas yra sprendimas, už kurį taip ar taip būsi atsakingas. Tau reikia žurnalo – bet tokio, kuris pats netaptų problema. Kode esantis komentaras pabrėžia svarbiausią failo eilutę: įrašyk veiksmą, priežastį ir ilgį, bet niekada – grynojo teksto. Vartotojų pranešimų saugojimas žurnalo faile tave įpareigoja laikytis duomenų apsaugos reikalavimų, kurie yra daug sunkesni nei teikiama paslauga.
import json
import time
from pathlib import Path
class ModerationLog:
"""Įrašo visus moderavimo sprendimus audito tikslais."""
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")
Jei visgi turi galėti atkurti konkretų pranešimą ginčo metu, įrašyk teksto maišos sumą (hash), o ne patį tekstą. Tai leidžia patvirtinti, kad tam tikras turinys atitinka užregistruotą sprendimą, nesaugant to turinio savo pusėje.
Svarbiausi punktai
- Moderuok tiek įvestį (užklausas), tiek išvestį (atsakymus)
- Naudok „Moderations“ API kaip pirmąjį, greitą ir nemokamą sluoksnį
- Koreguok slenkstines vertes kategorija po kategorijos, atsižvelgdamas į realią klaidingai neigiamo rezultato kainą
- Pridėk injekcijų aptikimą, žinodamas, kad jis pagauna tik naivius bandymus
- Įrašyk visus sprendimus auditui, nesaugodamas grynojo turinio