Satura moderācija, izmantojot API
Šajā lapā
Atjaunināts 2026. gada 3. novembrī, pamatojoties uz OpenAI Moderation rokasgrāmatu: kategorijas
illicitunillicit/violentmodelimomni-moderation-latestiepriekš trūka sarakstā un kodā. Avots: Moderation.
Satura moderācija, izmantojot API
OpenAI moderācijas API automātiski atklāj nepiemērotu saturu. Tas ir bezmaksas, būtisks rīks jebkurai lietotnei, kas pieņem lietotāju ģenerētu saturu. Iepriekšējā nodarbībā tu iemācījies rakstīt pielāgotus filtrus; šī nodarbība iepazīstina ar apmācītu klasifikatoru, kas spēj pamanīt to, ko regulārās izteiksmes nekad neatklās – slēptus draudus, netiešus apvainojumus un implicītus formulējumus.
Moderācijas API
Izsaukums ir apzināti minimālistisks: viens modelis, viens teksts un rezultāts, kas reducējas līdz loģiskai vērtībai. Lauks flagged sniedz atbildi uz bināro jautājumu: „Vai šis saturs pārkāpj lietošanas noteikumus?”, savukārt categories precizē, kuri tieši. Tā kā šis galapunkts ir bezmaksas, nav ekonomiska iemesla to izlaist, pat strādājot ar lieliem apjomiem.
from openai import OpenAI
client = OpenAI()
# Moderācijas API ir BEZMAKSAS
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}")
# Rezultāts:
# Content flagged: False
# Categories: Categories(harassment=False, hate=False, ...)
Moderācijas kategorijas
Aiz loģiskās vērtības slēpjas smalki izstrādāta režģa sistēma. Modelis atgriež lēmumu katrai kategorijai atsevišķi – uzmākšanās, draudoša uzmākšanās, naida runa, draudoša naida runa, norādes par nelikumīgām darbībām (ar vardarbību vai bez tās), paškaitējums ar tā variantiem (norādes un nodoms), seksuāls saturs, seksuāls saturs ar nepilngadīgajiem, vardarbība un grafiska vardarbība –, kā arī ticamības vērtējumu no 0,0 līdz 1,0 katrai no tām.
Šie vērtējumi ir nozīmīgāki par bināro lēmumu, ja vēlies precīzi noregulēt savu politiku. Profesionāla foruma platforma varētu vēlēties bloķēt saturu jau pie 0,3 uzmākšanās gadījumā, turpretī daiļliteratūras serviss varētu pieļaut 0,7 vardarbības gadījumā. Zemāk esošā funkcija nodrošina abus ieskata līmeņus: faktiski aktivizētās kategorijas un neapstrādātus vērtējumus tavu pašu sliekšņu noteikšanai.
def analyze_moderation(text: str) -> dict:
"""Detalizēta moderācijas analīze."""
moderation = client.moderations.create(
model="omni-moderation-latest",
input=text
)
result = moderation.results[0]
# Pieejamās kategorijas
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,
}
# Ticamības vērtējumi (no 0.0 līdz 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()},
}
# Tests
result = analyze_moderation("Hello everyone!")
print(f"Flagged: {result['flagged']}")
print(f"Scores: {result['main_scores']}")
Pilnīga moderācijas cauruļvada izveide
Lietotāju ievades moderēšana
Ietversim šo izsaukumu atkārtoti izmantojamā komponentē. ContentModerator atgriež skaidru pāri – pieņemams vai nē, kopā ar iemeslu –, nevis neapstrādātu objektu, kas katram izsaukumam būtu jāinterpretē no jauna. Kategoriju tulkošana skaidrā valodā ir svarīga: tā ir vārdnīca, kas parādīsies tavā saskarnē un žurnālos, un tai ir jābūt saprotamai cilvēku moderācijas komandai, kas pārņems situāciju.
class ContentModerator:
"""Satura moderators lietotnēm."""
def __init__(self, custom_threshold: float = 0.5):
self.client = OpenAI()
self.threshold = custom_threshold
def moderate(self, text: str) -> tuple[bool, dict]:
"""Moderē tekstu. Atgriež (ir_pieņemams, detaļas)."""
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("uzmākšanās")
if result.categories.hate:
categories.append("naida runa")
if result.categories.sexual:
categories.append("seksuāls saturs")
if result.categories.violence:
categories.append("vardarbība")
if result.categories.self_harm:
categories.append("paškaitējums")
return False, {
"reason": "Atklāts nepiemērots saturs",
"categories": categories
}
return True, {"reason": "Saturs ir pieņemams"}
def moderate_conversation(self, messages: list[str]) -> list[dict]:
"""Moderē ziņojumu sarakstu."""
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
# Lietošana
moderator = ContentModerator()
acceptable, details = moderator.moderate("Hello, how can I help you?")
print(f"Acceptable: {acceptable}")
print(f"Details: {details}")
Integrācija API cauruļvadā
Moderācija ietver izsaukumu abās pusēs. Ievades filtrēšana ļauj izvairīties no maksāšanas par ģenerēšanu saturam, ko tu tāpat noraidītu; izvades filtrēšana pasargā no gadījumiem, kad modelis, izmanīgi provocēts, pats ģenerē kaut ko nepieņemamu. Ņem vērā atšķirību apstrādē: ievades gadījumā tu vari lietotājam pateikt, kas tieši tika atklāts, jo viņš ir šī satura autors; izvades gadījumā ziņojumam jāpaliek vispārīgam, jo detaļu atklāšana nozīmētu aprakstīt to, ko modelis tikko ģenerējis.
def moderated_chatbot(user_input: str) -> str:
"""Čatbots ar gan ievades, gan izvades moderāciju."""
moderator = ContentModerator()
# 1. Moderē ievadi
input_ok, input_details = moderator.moderate(user_input)
if not input_ok:
return (f"Jūsu ziņojums tika bloķēts: "
f"{', '.join(input_details['categories'])}")
# 2. Ģenerē atbildi
response = client.responses.create(
model="gpt-5.6-terra",
instructions="Respond in a professional and safe manner.",
input=user_input
)
# 3. Moderē izvadi
output_ok, output_details = moderator.moderate(response.output_text)
if not output_ok:
return "Es nevaru sniegt šo atbildi."
return response.output_text
# Tests
print(moderated_chatbot("What is the capital of France?"))
Partijas (Batch) moderācija
Šis dubultais izsaukums rada latentumu, kas sarunās ir pieņemams, bet kļūst nepieļaujams, ja jāapstrādā desmit tūkstoši klientu atsauksmju, importētu no faila. Lai efektīvi moderētu lielus apjomus, nosūti masīvu tieši: API apstrādā visus tekstus vienā pieprasījumā un atgriež rezultātus tajā pašā secībā, ļaujot tos atkārtoti saistīt pēc indeksa.
def moderate_batch(texts: list[str]) -> list[dict]:
"""Moderē vairākus tekstus vienā pieprasījumā."""
results = []
# API pieņem ievades masīvu
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"Moderēti {len(texts)} teksti: {flagged_count} atzīmēti")
return results
# Lietošana
texts = [
"Hello, how are you?",
"Great product, I recommend it!",
"Customer service is excellent.",
]
results = moderate_batch(texts)
Moderācijas žurnālēšana
Moderācijas lēmums ietekmē lietotāju, un agrāk vai vēlāk tev būs tas jāattaisno – vai nu klientam, kas apstrīd bloķēšanu, vai regulatoram. Tāpēc sistemātiski žurnālē verdiktu, lietotāja ID, vērtējumus un teksta fragmentu. Žurnāla līmenis nošķir abus gadījumus: warning atzīmētam saturam, kas prasa cilvēka pārskatīšanu, un info pārējam, kas kalpo statistikas veidošanai.
import json
import logging
from datetime import datetime
logger = logging.getLogger("moderation")
def moderate_with_log(text: str, user_id: str = "anonymous") -> bool:
"""Moderē un žurnālē rezultātu auditam."""
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
# Lietošana
is_ok = moderate_with_log("Test message", user_id="user-123")
Viens pēdējais brīdinājums pirms turpinām: moderācija klasificē saturu; tā nesaprot nodomu. Pilnīgi pieklājīgs ziņojums, kas mēģina „ieslodzīt” (jailbreak) tavu asistentu, izies cauri visiem šiem filtriem, ne reizi netiekot atzīmēts. Par to būs runa nākamajā nodarbībā.
Galvenās atziņas
- Moderācijas API ir bezmaksas – izmanto to sistemātiski
- Moderē gan ievadi (lietotāja saturu), gan izvadi (modeļa atbildes)
- Modelis
omni-moderation-latestaptver visas satura kategorijas - Žurnālē visus moderācijas lēmumus auditam
- Izmanto partijas apstrādi, lai efektīvi moderētu lielus apjomus
- Moderācija papildina sistēmas instrukcijas; tā tās neaizstāj