Satura moderācija lielos apjomos
Šajā lapā
Nodarbība atjaunināta 2026. gada 3. novembrī, pamatojoties uz OpenAI dokumentāciju: parametri
temperatureuntop_ptiek pieņemti tikai ar spriešanas piepūli (reasoning effort) vērtībānone, savukārt GPT-5.6 modeļi pēc noklusējuma veic spriešanu (medium). Tādēļ izsaukumos, kuros iestatīti šie parametri, ir jānorādareasoning={"effort": "none"}(Responses API) vaireasoning_effort="none"(Chat Completions). Avoti: GPT-6 izmantošana · GPT-5.6 Terra.
Lietotāju aizsardzība ražošanas vidē
Tiklīdz tava lietotne nonāk tiešsaistē, tev jātiek galā ar nepiemērotu saturu — gan ievadē (ļaunprātīgi uzvedumi), gan izvadei (problemātiskas atbildes). Šī abpusējā prasība bieži pārsteidz komandas. Lielākā daļa vispirms domā par lietotāju sūtītā filtrašanu, taču reputācijas risks koncentrējas tajā, ko tava lietotne publicē tavā vārdā. Labi saskaņots modelis reti ģenerē šokējošu saturu pats no sevis, bet to var izdarīt, ja tiek spiests — un tavs zīmols parādās ekrānuzņēmuma augšdaļā.
Mēs pāriesim no viena API izsaukuma uz augstas caurlaidspējas asinhronu konveijeru, pakāpeniski palielinot mērogu.
Pirmais slānis: Moderations API
Moderations API klasificē tekstu vairākās riska kategorijās un atgriež gan bināru spriedumu, gan detalizētus rezultātus. Tas ir ātrs un bezmaksas, padarot to par dabisku pirmo filtru jebkurai publiskai lietotnei. Tālāk redzamā funkcija parāda tikai tās kategorijas, kuru rezultāti pārsniedz 0,3 — apzināti zemu slieksni. Šajā posmā tev jāredz, kas tuvojas robežai, ne tikai tas, kas to šķērso.
import openai
client = openai.OpenAI()
def moderate_content(text: str) -> dict:
"""Pārbauda, vai teksts satur nepiemērotu saturu."""
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
},
}
# Piemērs
result = moderate_content("How do I bake a chocolate cake?")
print(f"Flagged: {result['flagged']}")
Ražošanas vidē ar bināru spriedumu nepietiek. Atkarībā no satura un konteksta tev var būt vēlme to atļaut, pārrakstīt, bloķēt vai nodot cilvēkam — četri atšķirīgi lēmumi, kas kodā ir jānosauc tieši, nevis jāimprovizē ar boolea vērtībām. Tālāk redzamais konveijers formalizē šīs darbības, piemēro sliekšņus katrai kategorijai un pievieno otro slāni uzveduma injicēšanas (prompt-injection) noteikšanai.
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:
"""Daudzslāņu moderācijas konveijers."""
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:
"""Moderē ievades saturu (lietotāja uzvedums)."""
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"Nepiemērots saturs: {', '.join(problematic_categories)}",
)
# Uzveduma injicēšanas noteikšana
if self._detect_injection(text):
return ModerationResult(
action=ModerationAction.BLOCK,
reason="Konstatēts uzveduma injicēšanas mēģinājums",
)
return ModerationResult(action=ModerationAction.ALLOW)
def moderate_output(self, response: str) -> ModerationResult:
"""Moderē izvades saturu (LLM atbilde)."""
moderation = client.moderations.create(
model="omni-moderation-latest",
input=response,
)
if moderation.results[0].flagged:
return ModerationResult(
action=ModerationAction.BLOCK,
reason="Ģenerētā atbilde satur nepiemērotu saturu",
)
return ModerationResult(action=ModerationAction.ALLOW)
def _detect_injection(self, text: str) -> bool:
"""Nosaka uzveduma injicēšanas mēģinājumus."""
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)
Slieksnis 0,5 kategorijai self-harm — stingrāks nekā 0,7 citām kategorijām — ilustrē loģiku, kas tev jāpiemēro katram slieksnim. Šeit kļūdaini pozitīva rezultāta izmaksas nav salīdzināmas ar kļūdaini negatīva rezultāta izmaksām, tāpēc tu pazemini latiņu. Veic šo kompromisu kategoriju pa kategorijai, balstoties uz savu auditoriju, nevis piemērojot vienotu vērtību.
Uz marķieriem balstītai injicēšanas noteikšanai ir savs brīdinājums. Tā uztver naivus mēģinājumus, kas veido lielāko daļu apjoma, un neko vairāk: nedaudz atšķirīga formulējuma vai tulkota versija izslīd cauri. Uztver to kā trokšņa filtru, nevis aizsardzību. Patiesa aizsardzība pret injicēšanu ir arhitektūras jautājums — nekad nepiešķir modelim iespējas, ko nolaupīts uzvedums varētu izmantot.
Slodzes apstrāde
Augsta satiksmes lietotnē sinhrona moderācija kļūst par „pudeles kaklu”: katrs ziņojums gaida savu spriedumu pirms apstrādes. Asinhrons moderators atsaista šos soļus, rindojot saturu patēriņam vairākiem strādniekiem, vienlaikus izsekojot noderīgu statistiku.
import asyncio
class AsyncModerator:
"""Asinhroni moderē saturu augstai caurlaidspējai."""
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 "Nav moderēta satura."
return (
f"Kopā: {total} | "
f"Atļauts: {self.stats['allowed']} ({self.stats['allowed']/total:.1%}) | "
f"Bloķēts: {self.stats['blocked']} ({self.stats['blocked']/total:.1%})"
)
Blokēšanas koeficients, ko ģenerē report, ir tavs galvenais kalibrēšanas rādītājs. Ja tas pēkšņi lec līdz 15 %, darbojoties pie 0,5 %, pastāv tikai divi skaidrojumi: tu esi pakļauts koordinētam uzbrukumam vai tikko esi sabojājis savus sliekšņus. Abos gadījumos tev par to jāuzzina stundas laikā, nevis nākamajā ikmēneša pārskatā.
Ir vērts pieminēt vēl vienu ierobežojumu: Moderations API nezina neko par tavu biznesu. Ziņojums, kas kopumā ir pilnīgi pieņemams, var pārkāpt tavus paša noteikumus — piemēram, pieprasot medicīnisku padomu no bankas asistenta, mēģinot iegūt ārpus tīkla tarifu vai apejot procedūru. Kontekstuālā moderācija pievieno šo slāni, nosūtot ziņojumu modelim ar taviem skaidri definētiem noteikumiem, bet tikai pēc tam, kad standarta filtrs to ir laidis cauri.
def contextual_moderation(
text: str,
app_context: str,
business_rules: list[str],
) -> ModerationResult:
"""Kontekstam pielāgota moderācija, kas specifiska lietotnei."""
pipeline = ModerationPipeline()
standard_result = pipeline.moderate_input(text)
if standard_result.action == ModerationAction.BLOCK:
return standard_result
verification_prompt = (
f"Lietotnes konteksts: {app_context}\n\n"
f"Biznesa noteikumi pārbaudei:\n"
+ "\n".join(f"- {r}" for r in business_rules)
+ f"\n\nLietotāja ziņojums: {text}\n\n"
"Vai ziņojums atbilst visiem noteikumiem? "
"Atbildi jā vai nē ar īsu pamatojumu."
)
response = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature prasa 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)
Šo divu pārbaužu secībai ir nozīme. Bezmaksas, ātrais filtrs darbojas vispirms, un apmaksātais modeļa izsaukums notiek tikai tiem ziņojumiem, kas to ir izturējuši. Reālā satiksmē tas aptver gandrīz visus ziņojumus. Darīt otrādi — maksāt par modeļa izsaukumu saturam, ko Moderations API būtu noraidījis milisekunžu laikā — būtu izšķērdīgi.
Aizstāvama ieraksta uzturēšana
Moderācijas lēmums ir lēmums, par kuru tev būs jāatbild, vienā vai otrā veidā. Tev ir nepieciešams žurnāls — bet tāds, kas pats nekļūst par problēmu. Komentārs kodā izceļ vissvarīgāko rindu failā: fiksē darbību, iemeslu un garumu, nekad neapstrādātu tekstu. Lietotāju ziņojumu glabāšana žurnālfailā pakļauj tevi datu aizsardzības saistībām, kas ir daudz smagākas nekā sniegtais pakalpojums.
import json
import time
from pathlib import Path
class ModerationLog:
"""Reģistrē visus moderācijas lēmumus revīzijas vajadzībām."""
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),
# NELOGĒ neapstrādātu tekstu privātuma dēļ
}
with open(self.path, "a") as f:
f.write(json.dumps(entry) + "\n")
Ja tev tomēr ir jābūt iespējai izgūt konkrētu ziņojumu strīda gadījumā, žurnālē teksta hašiju, nevis pašu tekstu. Tas ļauj apstiprināt, ka konkrēts saturs atbilst reģistrētam lēmumam, nesaglabājot saturu savā pusē.
Galvenās atziņas
- Moderē gan ievades (uzvedumus), gan izvades (atbildes)
- Izmanto Moderations API kā savu pirmo, ātro un bezmaksas slāni
- Pielāgo sliekšņus kategoriju pa kategorijai, balstoties uz kļūdaini negatīva rezultāta reālajām izmaksām
- Pievieno injicēšanas noteikšanu, zinot, ka tā uztver tikai naivus mēģinājumus
- Žurnālē visus lēmumus revīzijai, neglabājot neapstrādātu saturu