Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Satura moderācija, izmantojot API

Nodarbība 19 no 22 Atjaunota 2026. gada 3. novembris Programmētājs
Šajā lapā
  1. Satura moderācija, izmantojot API
  2. Moderācijas API
  3. Moderācijas kategorijas
  4. Pilnīga moderācijas cauruļvada izveide
  5. Partijas (Batch) moderācija
  6. Moderācijas žurnālēšana
  7. Galvenās atziņas

Atjaunināts 2026. gada 3. novembrī, pamatojoties uz OpenAI Moderation rokasgrāmatu: kategorijas illicit un illicit/violent modelim omni-moderation-latest iepriekš 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-latest aptver 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