Indholdsmoderation med API'et
På denne side
Opdateret 3. november 2026 baseret på OpenAIs Moderation-guide: kategorierne
illicitogillicit/violentfor modellenomni-moderation-latestmanglede i listen og koden. Kilde: Moderation.
Indholdsmoderation med API’et
OpenAIs Moderation-API registrerer automatisk upassende indhold. Det er et gratis og uundværligt værktøj til enhver applikation, der accepterer brugergenereret indhold. Den forrige lektion viste dig, hvordan du skriver brugerdefinerede filtre; denne giver dig en trænet klassifikator, der opdager det, som regulære udtryk aldrig vil fange – skjulte trusler, indirekte fornærmelser og implicitte formuleringer.
Moderations-API’et
Kaldet er bevidst minimalt: én model, én tekst og et resultat, der koges ned til en boolean. Feltet flagged besvarer det binære spørgsmål: „Overtræder dette indhold brugsreglerne?”, mens categories specificerer hvilke. Da dette endpoint er gratis, er der ingen økonomisk grund til at springe det over, selv ved høje volumener.
from openai import OpenAI
client = OpenAI()
# Moderations-API'et er GRATIS
moderation = client.moderations.create(
model="omni-moderation-latest",
input="Hello, how are you?"
)
result = moderation.results[0]
print(f"Content flagged: {result.flagged}")
print(f"Categories: {result.categories}")
# Resultat:
# Content flagged: False
# Categories: Categories(harassment=False, hate=False, ...)
Moderationskategorier
Bag den booleanske værdi gemmer sig et finmasket gitter. Modellen returnerer en afgørelse pr. kategori – chikane, truende chikane, hadefuldt indhold, truende hadefuldt indhold, instrukser til ulovlige handlinger (med eller uden vold), selvskade med varianter (instrukser og hensigt), seksuelt indhold, seksuelt indhold involving mindreårige, vold og grafisk vold – sammen med en konfidensscore mellem 0,0 og 1,0 for hver.
Disse scorer er vigtigere end den binære afgørelse, når du vil kalibrere din politik. En professionel forumplatform vil måske blokere ved 0,3 for chikane, hvorimod en fiktions-tjeneste måske accepterer 0,7 for vold. Funktionen nedenfor eksponerer begge niveauer af indsigt: de kategorier, der faktisk er udløst, og de rå scorer til dine egne tærskler.
def analyze_moderation(text: str) -> dict:
"""Detaljeret moderationsanalyse."""
moderation = client.moderations.create(
model="omni-moderation-latest",
input=text
)
result = moderation.results[0]
# Tilgængelige kategorier
categories = {
"harassment": result.categories.harassment,
"harassment_threatening": result.categories.harassment_threatening,
"hate": result.categories.hate,
"hate_threatening": result.categories.hate_threatening,
"illicit": result.categories.illicit,
"illicit_violent": result.categories.illicit_violent,
"self_harm": result.categories.self_harm,
"self_harm_instructions": result.categories.self_harm_instructions,
"self_harm_intent": result.categories.self_harm_intent,
"sexual": result.categories.sexual,
"sexual_minors": result.categories.sexual_minors,
"violence": result.categories.violence,
"violence_graphic": result.categories.violence_graphic,
}
# Konfidensscorer (0,0 til 1,0)
scores = {
"harassment": result.category_scores.harassment,
"hate": result.category_scores.hate,
"self_harm": result.category_scores.self_harm,
"sexual": result.category_scores.sexual,
"violence": result.category_scores.violence,
}
return {
"flagged": result.flagged,
"detected_categories": [k for k, v in categories.items() if v],
"main_scores": {k: round(v, 4) for k, v in scores.items()},
}
# Test
result = analyze_moderation("Hello everyone!")
print(f"Flagged: {result['flagged']}")
print(f"Scores: {result['main_scores']}")
Komplet moderationspipeline
Moderation af brugerinput
Lad os pakke dette kald ind i en genanvendelig komponent. ContentModerator returnerer et eksplicit par – acceptabelt eller ej, med årsagen – i stedet for et rå objekt, som hver caller selv skulle fortolke. Det betyder noget at oversætte kategorier til klart sprog: dette er det ordforråd, der vil dukke op i din grænseflade og dine logs, og det skal være forståeligt for det menneskelige moderationsteam, der tager over.
class ContentModerator:
"""Indholdsmoderator til applikationer."""
def __init__(self, custom_threshold: float = 0.5):
self.client = OpenAI()
self.threshold = custom_threshold
def moderate(self, text: str) -> tuple[bool, dict]:
"""Modererer tekst. Returnerer (er_acceptabel, detaljer)."""
moderation = self.client.moderations.create(
model="omni-moderation-latest",
input=text
)
result = moderation.results[0]
if result.flagged:
categories = []
if result.categories.harassment:
categories.append("chikane")
if result.categories.hate:
categories.append("hadefuldt indhold")
if result.categories.sexual:
categories.append("seksuelt indhold")
if result.categories.violence:
categories.append("vold")
if result.categories.self_harm:
categories.append("selvskade")
return False, {
"reason": "Upassende indhold registreret",
"categories": categories
}
return True, {"reason": "Indhold acceptabelt"}
def moderate_conversation(self, messages: list[str]) -> list[dict]:
"""Modererer en liste med beskeder."""
results = []
for msg in messages:
acceptable, details = self.moderate(msg)
results.append({
"message": msg[:50] + "..." if len(msg) > 50 else msg,
"acceptable": acceptable,
**details
})
return results
# Brug
moderator = ContentModerator()
acceptable, details = moderator.moderate("Hello, how can I help you?")
print(f"Acceptable: {acceptable}")
print(f"Detaljer: {details}")
Integration i API-pipelinen
Moderation rammer kaldet på begge sider. Filtrering af input undgår, at du betaler for generering af indhold, du alligevel ville afvise; filtrering af output beskytter mod tilfælde, hvor modellen, hvis den provokeres dygtigt, producerer noget uacceptabelt selv. Bemærk forskellen i håndteringen: Ved input kan du fortælle brugeren, hvad der blev registreret, da de har skrevet det; ved output forbliver beskeden vag, fordi en detaljeret forklaring ville betyde at beskrive det, modellen lige har produceret.
def moderated_chatbot(user_input: str) -> str:
"""Chatbot med moderation af både input OG output."""
moderator = ContentModerator()
# 1. Moderér input
input_ok, input_details = moderator.moderate(user_input)
if not input_ok:
return (f"Din besked blev blokeret: "
f"{', '.join(input_details['categories'])}")
# 2. Generér svar
response = client.responses.create(
model="gpt-5.6-terra",
instructions="Respond in a professional and safe manner.",
input=user_input
)
# 3. Moderér output
output_ok, output_details = moderator.moderate(response.output_text)
if not output_ok:
return "Jeg kan ikke give det svar."
return response.output_text
# Test
print(moderated_chatbot("What is the capital of France?"))
Batch-moderation
Dette dobbelte kald tilføjer ventetid, hvilket er acceptabelt i samtaler, men bliver uoverkommeligt, når du skal behandle ti tusind kundeanmeldelser importeret fra en fil. For at moderere store volumener effektivt sender du en array direkte: API’et behandler alle tekster i én enkelt anmodning og returnerer resultaterne i samme rækkefølge, så du kan genkoble dem via indeks.
def moderate_batch(texts: list[str]) -> list[dict]:
"""Modererer flere tekster i én enkelt anmodning."""
results = []
# API'et accepterer en array af inputs
moderation = client.moderations.create(
model="omni-moderation-latest",
input=texts
)
for i, result in enumerate(moderation.results):
results.append({
"index": i,
"text_preview": texts[i][:50],
"flagged": result.flagged,
})
flagged_count = sum(1 for r in results if r["flagged"])
print(f"Modererede {len(texts)} tekster: {flagged_count} flagget")
return results
# Brug
texts = [
"Hello, how are you?",
"Great product, I recommend it!",
"Customer service is excellent.",
]
results = moderate_batch(texts)
Logning af moderation
En moderationsafgørelse påvirker en bruger, og før eller siden får du brug for at retfærdiggøre den – hvad enten det er over for en kunde, der bestrider en blokering, eller over for en tilsynsmyndighed. Derfor skal du systematisk logge dommen, bruger-ID’et, scorerne og et tekstuddrag. Log-niveauet skelner mellem de to tilfælde: warning for flagget indhold, der fortjener menneskelig gennemgang, og info for resten, som fodrer din statistik.
import json
import logging
from datetime import datetime
logger = logging.getLogger("moderation")
def moderate_with_log(text: str, user_id: str = "anonymous") -> bool:
"""Modererer og logger resultatet til revision."""
moderation = client.moderations.create(
model="omni-moderation-latest",
input=text
)
result = moderation.results[0]
log_entry = {
"timestamp": datetime.now().isoformat(),
"user_id": user_id,
"flagged": result.flagged,
"text_preview": text[:100],
"scores": {
"harassment": round(result.category_scores.harassment, 4),
"hate": round(result.category_scores.hate, 4),
"violence": round(result.category_scores.violence, 4),
}
}
if result.flagged:
logger.warning(json.dumps(log_entry))
else:
logger.info(json.dumps(log_entry))
return not result.flagged
# Brug
is_ok = moderate_with_log("Test message", user_id="user-123")
Én sidste advarsel, før vi går videre: moderation klassificerer indhold; den forstår ikke hensigt. En helt høflig besked, der forsøger at jailbryde din assistent, vil passere alle disse filtre uden nogensinde at blive flagget. Det er emnet for næste lektion.
Vigtige pointer
- Moderations-API’et er gratis – brug det systematisk
- Moderér både input (brugerindhold) OG output (modelsvar)
- Modellen
omni-moderation-latestdækker alle indholdskategorier - Log alle moderationsafgørelser til revision
- Brug batch-behandling til effektivt at moderere store volumener
- Moderation supplerer systeminstruktioner; den erstatter dem ikke