Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Indholdsmoderation i stor skala

Lektion 19 af 20 Opdateret 3. november 2026 Avanceret
På denne side
  1. Beskyt dine brugere i produktion
  2. Første lag: Moderations-API’en
  3. Håndtering af belastning
  4. At føre et forsvarligt register
  5. Vigtige pointer

Lektion opdateret 3. november 2026 baseret på OpenAI-dokumentation: temperature og top_p accepteres kun med en ræsonneringsindsats på none, hvorimod GPT-5.6-modeller ræsonnerer som standard (medium). Kald, der sætter disse parametre, skal derfor specificere reasoning={"effort": "none"} (Responses API) eller reasoning_effort="none" (Chat Completions). Kilder: Brug af GPT-6 · GPT-5.6 Terra.

Beskyt dine brugere i produktion

Så snart din applikation går live, skal du håndtere upassende indhold – både ved input (ondskabsfulde prompts) og output (problematiske svar). Dette krav om tovejskontrol overrasker ofte teams. De fleste tænker først på at filtrere det, brugerne sender, men omdømmerisikoen koncentrerer sig om det, din applikation offentliggør under dit navn. En velafstemt model genererer sjældent chokerende indhold af sig selv, men den kan gøre det, hvis den presses – og dit brand står øverst på skærmbilledet.

Vi bevæger os fra et enkelt API-kald til en asynkron pipeline med høj gennemstrømning og skalerer op trin for trin.

Første lag: Moderations-API’en

Moderations-API’en klassificerer tekst på tværs af flere risikokategorier og returnerer både en binær dom og detaljerede scorer. Den er hurtig og gratis, hvilket gør den til det naturlige første filter for enhver offentlig applikation. Funktionen nedenfor viser kun kategorier med scorer over 0,3 – en bevidst lav tærskel. På dette tidspunkt vil du se, hvad der nærmer sig grænsen, ikke kun hvad der krydser den.

import openai

client = openai.OpenAI()

def moderate_content(text: str) -> dict:
    """Tjek om tekst indeholder upassende indhold."""
    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
        },
    }

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

I produktion er en binær dom ikke nok. Afhængigt af indhold og kontekst vil du måske tillade det, omskrive det, blokere det eller eskalere det til et menneske – fire forskellige beslutninger, som du bør navngive eksplicit i koden i stedet for at improvisere med booleans. Pipelinen nedenfor formaliserer disse handlinger, anvender tærskler pr. kategori og tilføjer et andet lag til detektering af 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:
    """Moderations-pipeline i flere lag."""

    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ér input-indhold (bruger-prompt)."""
        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"Upassende indhold: {', '.join(problematic_categories)}",
            )

        # Detektering af prompt injection
        if self._detect_injection(text):
            return ModerationResult(
                action=ModerationAction.BLOCK,
                reason="Forsøg på prompt injection detekteret",
            )

        return ModerationResult(action=ModerationAction.ALLOW)

    def moderate_output(self, response: str) -> ModerationResult:
        """Moderér output-indhold (LLM-svar)."""
        moderation = client.moderations.create(
            model="omni-moderation-latest",
            input=response,
        )

        if moderation.results[0].flagged:
            return ModerationResult(
                action=ModerationAction.BLOCK,
                reason="Genereret svar indeholder upassende indhold",
            )

        return ModerationResult(action=ModerationAction.ALLOW)

    def _detect_injection(self, text: str) -> bool:
        """Detektér forsøg på prompt injection."""
        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)

Tærsklen på 0,5 for self-harm – strengere end 0,7 brugt til andre kategorier – illustrerer den ræsonnering, du bør anvende på hver tærskel. Her er omkostningen ved en falsk positiv langt fra omkostningen ved en falsk negativ, så du sænker barren. Foretag denne afvejning kategori for kategori baseret på dit publikum i stedet for at anvende en ensartet værdi.

Marker-baseret detektering af injection har en begrænsning. Den fanger naive forsøg, som udgør hovedparten af volumenet, og intet andet: en lidt anden formulering eller en oversat version slipper igennem. Behandl det som et støjfilter, ikke et forsvar. reel beskyttelse mod injection er arkitektonisk – giv aldrig modellen kapaciteter, som en kapret prompt kunne udnytte.

Håndtering af belastning

På en applikation med høj trafik bliver synkron moderation til en flaskehals: hver besked venter på sin dom før behandling. En asynkron moderator afkobler disse trin ved at købesætte indhold til forbrug af flere arbejdere, samtidig med at den løbende sporer nyttig statistik.

import asyncio

class AsyncModerator:
    """Moderér indhold asynkront for høj gennemstrømning."""

    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 "Intet indhold modereret."
        return (
            f"I alt: {total} | "
            f"Tilladt: {self.stats['allowed']} ({self.stats['allowed']/total:.1%}) | "
            f"Blokeret: {self.stats['blocked']} ({self.stats['blocked']/total:.1%})"
        )

Blokeringsraten produceret af report er din primære kalibreringsmetrik. Hvis den pludselig hopper til 15 % efter at have kørt på 0,5 %, findes der kun to forklaringer: Du er under et koordineret angreb, eller også har du lige ødelagt dine tærskler. I begge tilfælde vil du vide det inden for en time, ikke ved næste månedlige gennemgang.

Én sidste begrænsning fortjener omtale: Moderations-API’en ved intet om din forretning. En besked, der er fuldt acceptabel generelt, kan overtræde dine egne regler – f.eks. at anmode om medicinsk rådgivning fra en bankassistent, forsøge at opnå en off-grid-takst eller omgå en procedure. Kontekstuel moderation tilføjer dette lag ved at sende beskeden til en model med dine eksplicitte regler, men først efter at standardfilteret har tilladt den igennem.

def contextual_moderation(
    text: str,
    app_context: str,
    business_rules: list[str],
) -> ModerationResult:
    """Kontekstbevidst moderation skræddersyet til applikationen."""
    pipeline = ModerationPipeline()
    standard_result = pipeline.moderate_input(text)

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

    verification_prompt = (
        f"Applikationskontekst: {app_context}\n\n"
        f"Forretningsregler der skal verificeres:\n"
        + "\n".join(f"- {r}" for r in business_rules)
        + f"\n\nBrugerbesked: {text}\n\n"
        "Overholder beskeden alle regler? "
        "Svar ja eller nej med en kort begrundelse."
    )

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

Rækkefølgen af disse to tjek betyder noget. Det gratis, hurtige filter kører først, og kaldet til den betalte model sker kun for beskeder, der består det. Ved reel trafik dækker dette næsten alle beskeder. At gøre det omvendt – at betale for et modelkald på indhold, som Moderations-API’en ville have afvist på millisekunder – ville være spild.

At føre et forsvarligt register

En moderationsbeslutning er en beslutning, du vil blive holdt ansvarlig for, på den ene eller anden måde. Du har brug for en log – men en, der ikke bliver til et problem i sig selv. Kommentaren i koden fremhæver den vigtigste linje i filen: registrér handlingen, begrundelsen og længden, aldrig selve råteksten. At gemme brugerbeskeder i en logfil udsætter dig for databeskyttelsesforpligtelser, der er langt tungere end den leverede service.

import json
import time
from pathlib import Path

class ModerationLog:
    """Logfør alle moderationsbeslutninger til revisionsformål."""

    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),
            # LOG IKKE råtekst af hensyn til privatlivets fred
        }

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

Hvis du stadig skal kunne hente en specifik besked under en tvist, så log et hash af teksten i stedet for selve teksten. Dette giver dig mulighed for at bekræfte, at et givet stykke indhold matcher en registreret beslutning, uden at beholde indholdet på din side.

Vigtige pointer

  • Moderér både inputs (prompts) og outputs (svar)
  • Brug Moderations-API’en som dit første, hurtige og gratis lag
  • Justér tærskler kategori for kategori baseret på de reelle omkostninger ved en falsk negativ
  • Tilføj detektering af injection med viden om, at den kun fanger naive forsøg
  • Logfør alle beslutninger til revision uden at gemme råindhold