Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Sisu mõõdukas ulatuses

Õppetund 19 / 20 Värskendatud 3. november 2026 Edasijõudnutele
Sellel lehel
  1. Kasutajate kaitsmine tootmises
  2. Esimene kiht: Moderations API
  3. Koormuse haldamine
  4. Kaitstava kirje pidamine
  5. Peamised punktid

Tund uuendatud 3. novembril 2026 OpenAI dokumentatsiooni põhjal: parameetreid temperature ja top_p aktsepteeritakse ainult arutluskäigu jõupingutusega (effort) väärtusel none, samas kui GPT-5.6 mudelid kasutavad vaikimisi arutluskäiku (medium). Need parameetrid määravad kõned peavad seetõttu sisaldama reasoning={"effort": "none"} (Responses API) või reasoning_effort="none" (Chat Completions). Allikad: GPT-6 kasutamine · GPT-5.6 Terra.

Kasutajate kaitsmine tootmises

Niipea kui sinu rakendus läheb live’i, pead tegelema sobimatu sisuga – nii sisendis (kuritahtlikud vihjed) kui ka väljundis (probleemsed vastused). See kahepoolne nõue võtab meeskonnad sageli üllatusena. Enamik mõtleb esmalt kasutajate saadetava filtreerimisele, kuid maine risk koondub sellele, mida sinu rakendus avaldab sinu nime all. Hästi joondatud mudel genereerib harva iseenesest šokeerivat sisu, kuid surve all võib ta seda teha – ja sinu bränd ilmub ekraanitõmmise ülaossa.

Liigume ühest API kõnest suure läbilaskevõimega asünkroonse torustikuni, skaleerides seda samm-sammult.

Esimene kiht: Moderations API

Moderations API liigitab teksti mitme riskikategooria järgi ja tagastab nii binaarse otsuse kui ka üksikasjalikud skoorid. See on kiire ja tasuta, mistõttu on see loomulik esimene filter igale avalikule rakendusele. Allpool olev funktsioon toob välja ainult need kategooriad, mille skoor ületab 0,3 – see on tahtlikult madal lävi. Selles etapis tahad näha, mis läheneb piirile, mitte ainult seda, mis selle ületab.

import openai

client = openai.OpenAI()

def moderate_content(text: str) -> dict:
    """Kontrolli, kas tekst sisaldab sobimatut sisu."""
    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
        },
    }

# Näide
result = moderate_content("How do I bake a chocolate cake?")
print(f"Flagged: {result['flagged']}")

Tootmises ei piisa binaarsest otsusest. Sõltuvalt sisust ja kontekstist võid soovida selle lubada, ümber kirjutada, blokeerida või inimesele eskaleerida – need on neli erinevat otsust, mille peaksid koodis selgelt nimetama, mitte improviseerima boole’i väärtustega. Allpool olev torustik formaliseerib need tegevused, rakendab kategooriapõhiseid lävesid ja lisab teise kihi vihje-süste (prompt-injection) tuvastamiseks.

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:
    """Mitmekihiline mõõdukuse torustik."""

    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:
        """Mõõda sisendsisu (kasutaja vihje)."""
        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"Sobimatu sisu: {', '.join(problematic_categories)}",
            )

        # Vihje-süste (prompt injection) tuvastamine
        if self._detect_injection(text):
            return ModerationResult(
                action=ModerationAction.BLOCK,
                reason="Tuvastati vihje-süste rünnaku katse",
            )

        return ModerationResult(action=ModerationAction.ALLOW)

    def moderate_output(self, response: str) -> ModerationResult:
        """Mõõda väljundsisu (LLM vastus)."""
        moderation = client.moderations.create(
            model="omni-moderation-latest",
            input=response,
        )

        if moderation.results[0].flagged:
            return ModerationResult(
                action=ModerationAction.BLOCK,
                reason="Genereeritud vastus sisaldab sobimatut sisu",
            )

        return ModerationResult(action=ModerationAction.ALLOW)

    def _detect_injection(self, text: str) -> bool:
        """Tuvasta vihje-süste rünnaku katsed."""
        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)

Lävi 0,5 kategooriale self-harm – rangem kui teiste kategooriate puhul kasutatav 0,7 – illustreerib arutluskäiku, mida peaksid iga läve puhul rakendama. Siin on valepositiivse tulemuse hind mitte kusagil valenegatiivse tulemuse hinna lähedal, seega langetad latti. Tee see kompromiss kategooria haaval, lähtudes oma sihtrühmast, mitte ära rakenda ühtset väärtust.

Markeritel põhineval tuvastamisel on üks aga. See püüab kinni naiivsed katsed, mis moodustavad suurema osa mahust, ja mitte midagi enamat: veidi erinev sõnastus või tõlgitud versioon pääseb läbi. Käitle seda mürafiltrina, mitte kaitsevahendina. Tegeliku kaitse võti süste vastu on arhitektuuriline – ära anna mudelile kunagi võimeid, mida kaaperdatud vihje ära kasutada saaks.

Koormuse haldamine

Suure liiklusega rakenduses muutub sünkroonne mõõdukus pudelikaelaks: iga sõnum ootab oma otsust enne töötlemist. Asünkroonne moderaator eraldab need sammud, järjestades sisu tarbimiseks mitmele töötajale, jälgides samal ajal kasulikke statistikat.

import asyncio

class AsyncModerator:
    """Mõõda sisu asünkroonselt suure läbilaskevõime jaoks."""

    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 "Sisu ei ole mõõdetud."
        return (
            f"Kokku: {total} | "
            f"Lubatud: {self.stats['allowed']} ({self.stats['allowed']/total:.1%}) | "
            f"Blokeeritud: {self.stats['blocked']} ({self.stats['blocked']/total:.1%})"
        )

Funktsiooni report poolt genereeritud blokeerimismäär on sinu peamine kalibreerimismeetrik. Kui see hüppab äkki 0,5%-lt 15%-le, on ainult kaks seletust: oled koordineeritud rünnaku all või just rikkusid oma läved. Mõlemal juhul tahad seda teada tunni jooksul, mitte järgmisel kuuülevaatusel.

Väärib mainimist veel üht piirangut: Moderations API ei tea midagi sinu ärist. Sõnum, mis on üldiselt täiesti vastuvõetav, võib rikkuda sinu enda reegleid – näiteks meditsiinilise nõu küsimine pangandusassistendilt, võrguvälise hinna hankimise katse või protseduuri möödahiilimine. Kontekstipõhine mõõdukus lisab selle kihi, esitades sõnumi mudelile koos sinu selgete reeglitega, kuid alles pärast seda, kui standardfilter on selle läbi lasknud.

def contextual_moderation(
    text: str,
    app_context: str,
    business_rules: list[str],
) -> ModerationResult:
    """Rakendusele kohandatud kontekstitundlik mõõdukus."""
    pipeline = ModerationPipeline()
    standard_result = pipeline.moderate_input(text)

    if standard_result.action == ModerationAction.BLOCK:
        return standard_result

    verification_prompt = (
        f"Rakenduse kontekst: {app_context}\n\n"
        f"Kontrollitavad ärireeglid:\n"
        + "\n".join(f"- {r}" for r in business_rules)
        + f"\n\nKasutaja sõnum: {text}\n\n"
        "Kas sõnum vastab kõigile reeglitele? "
        "Vasta jah või ei koos lühike põhjendusega."
    )

    response = client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # temperature nõuab 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)

Nende kahe kontrolli järjekord on oluline. Tasuta ja kiire filter töötab esimesena ning tasuline mudelikõne toimub ainult nende sõnumite puhul, mis sellest läbi pääsevad. Reaalses liikluses katab see peaaegu kõik sõnumid. Vastupidine tegutsemine – maksmine mudelikõne eest sisu eest, mille Moderations API oleks millisekunditega tagasi lükanud – oleks raiskav.

Kaitstava kirje pidamine

Mõõdukusotsus on otsus, mille eest vastutad ühel või teisel viisil. Vajad logi – aga sellist, mis ei muutuks ise probleemiks. Koodis olev kommentaar toob esile faili kõige olulisema rea: salvesta tegevus, põhjus ja pikkus, mitte kunagi toorest teksti. Kasutajasõnumite logifaili salvestamine seab sind andmekaitsekohustustele, mis on palju raskemad kui pakutav teenus.

import json
import time
from pathlib import Path

class ModerationLog:
    """Logi kõik mõõdukusotsused auditeerimise eesmärgil."""

    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),
            # ÄRA logi toorest teksti privaatsuse huvides
        }

        with open(self.path, "a") as f:
            f.write(json.dumps(entry) + "\n")

Kui pead vaidluse korral siiski suutma konkreetset sõnumit retrieve’ida, logi teksti räsi mitte teksti ennast. See võimaldab sul kinnitada, et antud sisu vastab registreeritud otsusele, hoidmata sisu enda poolt alles.

Peamised punktid

  • Mõõda nii sisendeid (vihjeid) kui ka väljundeid (vastuseid)
  • Kasuta Moderations API-d oma esimese, kiire ja tasuta kihina
  • Kohanda lävesid kategooria haaval, lähtudes valenegatiivse tulemuse tegelikust hinnast
  • Lisa süste tuvastamine, teades, et see püüab kinni ainult naiivsed katsed
  • Logi kõik otsused auditeerimiseks, salvestamata toorest sisu