Turinio moderavimas naudojant API
Šiame puslapyje
Atnaujinta 2026 m. lapkričio 3 d. pagal OpenAI Moderation gaires: sąraše ir kode trūko
illicitbeiillicit/violentkategorijų, skirtųomni-moderation-latestmodeliui. Šaltinis: Moderation.
Turinio moderavimas naudojant API
OpenAI moderavimo API automatiškai aptinka netinkamą turinį. Tai nemokamas ir būtinas įrankis bet kuriai programai, priimančiai naudotojų sukurtą turinį. Ankstesnėje pamokoje sužinojai, kaip rašyti savo filtrus; šiame skyriuje gausi apmokytą klasifikatorių, kuris pastebi tai, ko reguliarieji reiškiniai niekada nepagaus – užslėptas grėsmes, netiesioginius įžeidimus ir implicitines formuluotes.
Moderavimo API
Užklausa sąmoningai padaryta minimali: vienas modelis, vienas tekstas ir rezultatas, kuris susiveda į loginę reikšmę. Laukas flagged atsako į binarinį klausimą: „Ar šis turinys pažeidžia naudojimo taisykles?“, o categories nurodo, kurios konkrečiai. Kadangi ši pabaiga yra nemokama, nėra jokios ekonominės priežasties jos praleisti, net ir esant dideliems kiekiams.
from openai import OpenAI
client = OpenAI()
# Moderavimo API yra NEMOKAMAS
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}")
# Result:
# Content flagged: False
# Categories: Categories(harassment=False, hate=False, ...)
Moderavimo kategorijos
Už loginės reikšmės slypi detalus tinklelis. Modelis grąžina sprendimą kiekvienai kategorijai – priekabiavimas, grėsmingas priekabiavimas, neapykanta, grėsminga neapykanta, nurodymai vykdyti neteisėtus veiksmus (su smurtu arba be jo), savižala su jos variantais (nurodymai ir ketinimas), seksualinis turinys, seksualinis turinys, susijęs su nepilnamečiais, smurtas ir grafinis smurtas – kartu su pasitikėjimo įverčiu nuo 0,0 iki 1,0 kiekvienai iš jų.
Šie įverčiai yra svarbesni už binarinį sprendimą, kai nori sureguliuoti savo politiką. Profesionalus forumo tinklalapis gali norėti blokuoti ties 0,3 priekabiavimo atveju, tuo tarpu fikcijos paslauga gali priimti 0,7 smurto atveju. Toliau pateikta funkcija atskleidžia abu įžvalgų lygmenis: faktiskai suaktyvintas kategorijas ir žalius įverčius tavo pačių slenksčiams nustatyti.
def analyze_moderation(text: str) -> dict:
"""Išsami moderavimo analizė."""
moderation = client.moderations.create(
model="omni-moderation-latest",
input=text
)
result = moderation.results[0]
# Galimos kategorijos
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,
}
# Pasitikėjimo įverčiai (nuo 0.0 iki 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()},
}
# Testas
result = analyze_moderation("Hello everyone!")
print(f"Flagged: {result['flagged']}")
print(f"Scores: {result['main_scores']}")
Pilna moderavimo grandinė
Naudotojų įvesties moderavimas
Apvyniokime šį kvietimą į pakartotinai naudojamą komponentą. ContentModerator grąžina aiškią porą – priimtina ar ne, kartu su priežastimi – vietoj žalių objektų, kuriuos kiekvienas kviečiantysis turėtų aiškinti iš naujo. Kategorijų vertimas į aiškią kalbą yra svarbus: tai yra žodynas, kuris atsiras tavo sąsajoje ir žurnaluose, ir jis turi būti suprantamas žmonių moderavimo komandai, kuri perims darbą.
class ContentModerator:
"""Programų turinio moderatorius."""
def __init__(self, custom_threshold: float = 0.5):
self.client = OpenAI()
self.threshold = custom_threshold
def moderate(self, text: str) -> tuple[bool, dict]:
"""Moderuoja tekstą. Grąžina (ar_priimtina, detalės)."""
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("harassment")
if result.categories.hate:
categories.append("hate speech")
if result.categories.sexual:
categories.append("sexual content")
if result.categories.violence:
categories.append("violence")
if result.categories.self_harm:
categories.append("self-harm")
return False, {
"reason": "Nustatytas netinkamas turinys",
"categories": categories
}
return True, {"reason": "Turinys priimtinas"}
def moderate_conversation(self, messages: list[str]) -> list[dict]:
"""Moderuoja pranešimų sąrašą."""
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
# Naudojimas
moderator = ContentModerator()
acceptable, details = moderator.moderate("Hello, how can I help you?")
print(f"Acceptable: {acceptable}")
print(f"Details: {details}")
Integravimas į API grandinę
Moderavimas aprėmia kvietimą iš abiejų pusių. Įvesties filtravimas leidžia išvengti mokėjimo už generavimą turiniui, kurį bet kuriuo atveju atmestum; išvesties filtravimas apsaugo nuo atvejų, kai modelis, gudriai išprovokuotas, pats sugeneruoja ką nors nepriimtino. Atkreipk dėmesį į skirtumą tvarkant: įvesties atveju gali pasakyti naudotojui, kas buvo nustatyta, nes jis tai parašė; išvesties atveju žinutė lieka miglota, nes jos detalizavimas reikštų aprašymą to, ką modelis tik ką sugeneravo.
def moderated_chatbot(user_input: str) -> str:
"""Pokalbių botas su tiek įvesties, TIEK išvesties moderavimu."""
moderator = ContentModerator()
# 1. Moderuoti įvestį
input_ok, input_details = moderator.moderate(user_input)
if not input_ok:
return (f"Jūsų žinutė buvo užblokuota: "
f"{', '.join(input_details['categories'])}")
# 2. Generuoti atsakymą
response = client.responses.create(
model="gpt-5.6-terra",
instructions="Respond in a professional and safe manner.",
input=user_input
)
# 3. Moderuoti išvestį
output_ok, output_details = moderator.moderate(response.output_text)
if not output_ok:
return "I am unable to provide that response."
return response.output_text
# Testas
print(moderated_chatbot("What is the capital of France?"))
Grupinis moderavimas
Šis dvigubas kvietimas prideda delsos, kas pokalbyje yra priimtina, bet tampa draudžiama, kai reikia apdoroti dešimt tūkstančių klientų atsiliepimų, importuotų iš failo. Norint efektyviai moderuoti didelius kiekius, perduok masyvą tiesiogiai: API apdoroja visus tekstus vienoje užklausoje ir grąžina rezultatus ta pačia tvarka, leisdamas juos susieti pagal indeksą.
def moderate_batch(texts: list[str]) -> list[dict]:
"""Vienu metu moderuoja kelis tekstus vienoje užklausoje."""
results = []
# API priima įvesties masyvą
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"Moderated {len(texts)} texts: {flagged_count} flagged")
return results
# Naudojimas
texts = [
"Hello, how are you?",
"Great product, I recommend it!",
"Customer service is excellent.",
]
results = moderate_batch(texts)
Moderavimo žurnalų vedimas
Moderavimo sprendimas paveikia naudotoją, ir anksčiau ar vėliau tau reikės jį pagrįsti – nesvarbu, ar tai būtų klientas, ginčijantis bloką, ar reguliavimo institucija. Todėl sistemiškai fiksuok verdiktą, naudotojo ID, įverčius ir teksto ištrauką. Žurnalo lygmuo atskiria du atvejus: warning pažymėtam turiniui, kuris nusipelno žmogaus peržiūros, ir info visam kitam, kuris maitina tavo statistiką.
import json
import logging
from datetime import datetime
logger = logging.getLogger("moderation")
def moderate_with_log(text: str, user_id: str = "anonymous") -> bool:
"""Moderuoja ir įrašo rezultatą į žurnalą auditui."""
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
# Naudojimas
is_ok = moderate_with_log("Test message", user_id="user-123")
Vienas paskutinis įspėjimas prieš judant toliau: moderavimas klasifikuoja turinį; jis nesupranta ketinimų. Visiškai mandagi žinutė, bandanti „nulaužti“ tavo asistentą, praeis visus šiuos filtrus nė karto nepažymėta. Tai bus kitos pamokos tema.
Svarbiausi punktai
- Moderavimo API yra nemokamas – naudok jį sistemiškai
- Moderuok tiek įvestį (naudotojų turinį), TIEK išvestį (modelio atsakymus)
- Modelis
omni-moderation-latestapima visas turinio kategorijas - Fiksuok visus moderavimo sprendimus auditui
- Naudok grupinį apdorojimą norėdamas efektyviai moderuoti didelius kiekius
- Moderavimas papildo sistemos instrukcijas; jis jų nepakeičia