Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Satura moderācija lielos apjomos

Nodarbība 19 no 20 Atjaunota 2026. gada 3. novembris Augstākais
Šajā lapā
  1. Lietotāju aizsardzība ražošanas vidē
  2. Pirmais slānis: Moderations API
  3. Slodzes apstrāde
  4. Aizstāvama ieraksta uzturēšana
  5. Galvenās atziņas

Nodarbība atjaunināta 2026. gada 3. novembrī, pamatojoties uz OpenAI dokumentāciju: parametri temperature un top_p tiek 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āda reasoning={"effort": "none"} (Responses API) vai reasoning_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