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

OpenAI moderatsiooni API

Õppetund 5 / 14 Värskendatud 3. november 2026 Edasijõudnutele
Sellel lehel
  1. Sisseehitatud moderatsioonitööriist
  2. Mida API tagastab
  3. Tuvastatud kategooriad
  4. Torustiku mõlema otsa moderatsioon
  5. Mida see API ei tee
  6. Peamised punktid

Uuendatud 3. novembril 2026 OpenAI Moderation juhendi põhjal: lisatud kategooria illicit (ja illicit/violent), mis tabelist puudus, koos piltidele kohaldatavate kategooriatega. Allikas: Moderation.

Sisseehitatud moderatsioonitööriist

OpenAI pakub tasuta moderatsiooni API-d, mis analüüsib teksti, et tuvastada potentsiaalselt kahjulikku sisu. See on esimene kaitsekiht, mille peaksid integreerima igasse OpenAI mudeleid kasutavasse rakendusse, ja sa ei piirdu ainult selle kasutusjuhtumiga: kuna see võtab sisendina vastu toorteksti, saad seda kasutada ka teistele mudelitele suunatud sisu filtreerimiseks. Asjaolu, et see on tasuta, muudab probleemi lähenemist. Tavalised kompromissid – kas moderateerida iga päringut või ainult kahtlaseid? – kaotavad oma kaalu, kuna ainus allesjäänud kulu on latentsus.

Mida API tagastab

Põhipäring mahub ühele reale; tähelepanu nõuab vastus. API tagastab kolm erinevat elementi:布尔i flagged, mis peegeldab OpenAI otsust, tegelikult käivitunud kategooriate loetelu ja, mis kõige tähtsam, pidevad skoorid iga kategooria kohta. Just need skoorid teevad tootmises vahet, sest need võimaldavad sul endal otsustada, kuhu piir tõmmata, selle asemel et pärida üldkasutuseks mõeldud lävendit.

from openai import OpenAI

client = OpenAI()

def moderate_content(text: str) -> dict:
    """Analüüsib teksti OpenAI moderatsiooni API kaudu."""
    response = client.moderations.create(input=text)
    result = response.results[0]

    return {
        "blocked": result.flagged,
        "categories": {
            cat: flagged
            for cat, flagged in result.categories.__dict__.items()
            if flagged
        },
        "scores": {
            cat: round(score, 4)
            for cat, score in result.category_scores.__dict__.items()
            if score > 0.01
        },
    }

# Testi erinevat tüüpi sisuga
examples = [
    "How do I bake a chocolate cake?",
    "I will kill you if you don't answer me",
    "Explain how AES encryption works",
]

for text in examples:
    result = moderate_content(text)
    status = "BLOCKED" if result["blocked"] else "OK"
    print(f"{status} : {text[:50]}...")
    if result["categories"]:
        print(f"  Categories : {list(result['categories'].keys())}")

Kolm testnäidet pole juhuslikud: esimene peaks läbi minema, teine tuleks blokeerida ja kolmas – täiesti legitiimne tehniline küsimus – näitab, kuidas sinu torustik käitub turvalisussõnavaraga kokku puutudes. Just selliseid päringuid käsitleb küberturbe meeskond iga päev.

Tuvastatud kategooriad

API liigitab problemaatilise sisu mitme telje järgi, millest igaüks vastab erinevale kahju tüübile.

Kategooria Kirjeldus
harassment Ahistamine, ähvardused, hirmutamine
hate Identiteedil põhinev vihakõne
illicit Nõuanded või juhised ebaseaduslike tegude sooritamiseks
self-harm Enesevigastamine, enesetapp
sexual Selge seksuaalne sisu
violence Graafiline vägivald, ähvardused

Igal kategoorial on ka alamkategooriad (nt harassment/threatening, illicit/violent, violence/graphic) täpsemaks filtreerimiseks. Mudeliga omni-moderation-latest kohalduvad piltidele ainult self-harm ja selle variandid, sexual ning violence (koos violence/graphic-ga); teised kategooriad kehtivad ainult teksti kohta. See granulaarsus hoiab sind tegemast jämedaid kompromisse: foorumi moderatsiooniplatvorm võib soovida blokeerida harassment/threatening, taludes samal ajal lihtsat harassment-i, mis hõlmab paljusid tavapäraseid vaidlusi.

Kui pead töötlema suuri koguseid – näiteks vestlusajaloo tagantjärele analüüsimine –, võtab API vastu loendi ja tagastab tulemuse iga elemendi kohta, vältides mitut võrgupäringut.

def moderate_batch(messages: list[str]) -> list[dict]:
    """Moderatsioonib mitu sõnumit ühes päringus."""
    response = client.moderations.create(input=messages)
    results = []
    for i, result in enumerate(response.results):
        results.append({
            "index": i,
            "text": messages[i][:50],
            "blocked": result.flagged,
            "max_score": max(
                score
                for score in result.category_scores.__dict__.values()
            ),
        })
    return results

Torustiku mõlema otsa moderatsioon

Levinud viga on moderateerida ainult sisendeid. See tugineb valele intuitsioonile: kui saabuv sõnum on vastuvõetav, on ka vastus korras. Ometi võib mudel genereerida problemaatilist sisu neutraalsest päringust, eriti kui see tugineb taastatud dokumentidele, mille sisu keegi ei ole kontrollinud. Allpool olev klass rakendab seetõttu mõlemas suunas sama käsitlust, lisades kohandatud lävendi, mis teravdab API vaikimisi otsust.

class ModerationPipeline:
    """Sisendi ja väljundi moderatsiooni torustik LLM-rakendusele."""

    def __init__(self, custom_threshold: float = 0.7):
        self.client = OpenAI()
        self.threshold = custom_threshold

    def moderate_input(self, message: str) -> tuple[bool, dict]:
        """Moderatsioonib sõnumi ENNE mudelile saatmist."""
        result = self.client.moderations.create(input=message).results[0]
        scores = result.category_scores.__dict__
        high_categories = {
            cat: score for cat, score in scores.items() if score > self.threshold
        }
        blocked = result.flagged or bool(high_categories)
        return blocked, {"flagged_api": result.flagged, "custom_categories": high_categories}

    def moderate_output(self, response: str) -> tuple[bool, dict]:
        """Moderatsioonib mudeli vastuse ENNE kasutajale saatmist."""
        return self.moderate_input(response)

    def process_message(self, user_message: str, system_prompt: str) -> str:
        """Täielik torustik: sisendi moderatsioon, LLM, väljundi moderatsioon."""
        # 1. samm: sisendi moderatsioon
        input_blocked, details = self.moderate_input(user_message)
        if input_blocked:
            return "Sinu sõnumit ei saa töödelda. Palun sõnasta see ümber."

        # 2. samm: pöördumine mudeli poole
        response = self.client.chat.completions.create(
            model="gpt-5.6-sol",
            messages=[
                {"role": "system", "content": system_prompt},
                {"role": "user", "content": user_message},
            ],
        )
        model_response = response.choices[0].message.content

        # 3. samm: väljundi moderatsioon
        output_blocked, _ = self.moderate_output(model_response)
        if output_blocked:
            return "Vastus filtreeriti mittevastavuse tõttu."

        return model_response

# Kasutamine
pipeline = ModerationPipeline(custom_threshold=0.5)
response = pipeline.process_message(
    "How do I protect my application against SQL injections?",
    "You are an expert in defensive cybersecurity."
)
print(response)

Mida see API ei tee

Selle kõige olulisem piirang on ka kõige valemini mõistetud: see ei tuvasta sisendimanipulatsiooni (prompt injection). Viisakas sõnum, mis on sisu seisukohalt täiesti kahjutu, kuid palub mudelil oma juhiseid eirata, pääseb läbi ilma ühtegi kategooriat käivitamata. Oodata, et see kaitseb manipuleerimise eest, on nagu paigaldada suitsuandur ja loota, et see peatab vargad.

Valepositiivsed tulemused on teine piirang, eriti tundlik turvalisuse või meditsiini kontekstis, kus ohu kirjeldamine on töö osa. Igale päringule lisandub täiendav võrgukõne, mis on oluline, kui taotled reaalajas vastuseid. Tuvastamine on inglise keeles usaldusväärsem kui teistes keeltes – pimekoht, mida ründajad suurepäraselt tunnevad. Lõpuks muutuvad kategooriad ja lävendid uuendustega: kuus kuud tagasi kalibreeritud komplekt väärib uuesti kontrollimist.

Need piirangud dikteerivad, kuidas tööriista kasutada. Moderateeri mõlemas suunas, kohanda lävendeid kategooria haaval, mitte globaalselt, ja kombineeri seda süstemaatiliselt teiste kihtidega – sisendimanipulatsiooni tuvastamine, äriloogika filtreerimine –, mida järgmised tunnid detailselt kirjeldavad. Logi tulemused, sest oma valepositiivsete tulemuste jälgimine on viis, kuidas õpid, kuhu liugureid nihutada. Ja planeeri juhuks, kui API pole kättesaadav: otsusta juba praegu, kui asjad on rahulikud, kas sinu rakendus peaks vaikimisi blokeerima või laskma liikluse läbi, selle asemel et seda käitumist intsidenti ajal avastada.

Peamised punktid

  • Moderatsiooni API on tasuta, kiire ja lihtne integreerida
  • See tuvastab solvavat sisu, kuid mitte sisendimanipulatsiooni ega vanglast vabastamist (jailbreaks)
  • Sisendi-mudeli-väljundi torustikku tuleb moderateerida mõlemast otsast
  • Vaikimisi lävendid sobivad harva – kohanda neid oma kontekstiga
  • See on üks kiht teiste seas, mitte kunagi ainus kaitsejoon