Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Moderiranje vsebine z API-jem

Lekcija 19 od 22 Posodobljeno 3. november 2026 Razvijalec
Na tej strani
  1. Moderiranje vsebine z API-jem
  2. API za moderiranje
  3. Kategorije moderiranja
  4. Celoten cevovod za moderiranje
  5. Paketno moderiranje
  6. Beleženje moderiranja
  7. Ključne ugotovitve

Posodobljeno 3. novembra 2026 na podlagi OpenAI-jevega vodnika Moderation: kategoriji illicit in illicit/violent za model omni-moderation-latest sta manjkali na seznamu in v kodi. Vir: Moderation.

Moderiranje vsebine z API-jem

OpenAI-jev API za moderiranje samodejno zazna neustrezno vsebino. Je brezplačno in bistveno orodje za vsako aplikacijo, ki sprejema vsebino, ki jo ustvarijo uporabniki. Prejšnja lekcija ti je pokazala, kako napisati prilagojene filtre; ta ti ponuja naučen klasifikator, ki zazna tisto, česar regularni izrazi nikoli ne bodo ujeli – prikrite grožnje, posredne žalitve in implicitna sporočila.

API za moderiranje

Klic je namerno minimalističen: en model, eno besedilo in rezultat, ki se zreducira na boolean vrednost. Polje flagged odgovori na binarno vprašanje: „Ali ta vsebina krši pravila uporabe?”, medtem ko categories podrobneje opiše, katere kategorije so bile sprožene. Ker je ta končna točka brezplačna, ni ekonomskega razloga, da bi jo preskočili, tudi pri velikih količinah.

from openai import OpenAI
client = OpenAI()

# API za moderiranje je BREZPLAČEN
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, ...)

Kategorije moderiranja

Za boolean vrednostjo se skriva fino razčlenjena mreža. Model vrne odločitev za vsako kategorijo posebej – nadlegovanje, grozeče nadlegovanje, sovražni govor, grozeči sovražni govor, navodila za nedovoljena dejanja (z nasiljem ali brez), samopoškodovanje z različicami (navodila in namen), spolna vsebina, spolna vsebina, ki vključuje mladoletnike, nasilje in grafično nasilje – skupaj s stopnjo zanesljivosti med 0,0 in 1,0 za vsako od njih.

Te ocene so pomembnejše od binarne odločitve, ko želiš umeriti svojo politiko. Profesionalna forumna platforma bi morda želela blokirati pri 0,3 za nadlegovanje, medtem ko bi storitev za fikcijo lahko sprejela 0,7 za nasilje. Spodnja funkcija razkriva obe ravni vpogleda: dejansko sprožene kategorije in surove ocene za tvoje lastne pragove.

def analyze_moderation(text: str) -> dict:
    """Podrobna analiza moderiranja."""
    moderation = client.moderations.create(
        model="omni-moderation-latest",
        input=text
    )

    result = moderation.results[0]

    # Razpoložljive kategorije
    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,
    }

    # Stopnje zanesljivosti (0.0 do 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']}")

Celoten cevovod za moderiranje

Moderiranje uporabniških vnosov

Ovijmo ta klic v ponovno uporabno komponento. ContentModerator vrne ekspliciten par – sprejemljivo ali ne, z razlogom – namesto surovega objekta, ki bi ga moral vsak klicatelj znova razlagati. Prevajanje kategorij v jasen jezik je ključno: to je besedišče, ki se bo pojavilo v tvojem vmesniku in dnevnikih, razumeti pa ga mora tudi ekipa za ročno moderiranje, ki prevzame nadzor.

class ContentModerator:
    """Moderator vsebine za aplikacije."""

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

    def moderate(self, text: str) -> tuple[bool, dict]:
        """Moderira besedilo. Vrne (je_sprejemljivo, podrobnosti)."""
        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("nadlegovanje")
            if result.categories.hate:
                categories.append("sovražni govor")
            if result.categories.sexual:
                categories.append("spolna vsebina")
            if result.categories.violence:
                categories.append("nasilje")
            if result.categories.self_harm:
                categories.append("samopoškodovanje")

            return False, {
                "reason": "Zaznana neustrezna vsebina",
                "categories": categories
            }

        return True, {"reason": "Vsebina je sprejemljiva"}

    def moderate_conversation(self, messages: list[str]) -> list[dict]:
        """Moderira seznam sporočil."""
        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

# Uporaba
moderator = ContentModerator()
acceptable, details = moderator.moderate("Hello, how can I help you?")
print(f"Acceptable: {acceptable}")
print(f"Details: {details}")

Integracija v cevovod API-ja

Moderiranje obdaja klic na obeh straneh. Filtriranje vhoda prepreči plačevanje za generiranje vsebine, ki bi jo tako ali tako zavrnili; filtriranje izhoda pa ščiti pred primeri, ko model, spretno provociran, sam proizvede nekaj nesprejemljivega. Upoštevaj razliko v obravnavi: pri vhodu lahko uporabniku poveš, kaj je bilo zaznano, saj je avtor on; pri izhodu sporočilo ostane nejasno, saj bi podrobnosti pomenile opisovanje tega, kar je model pravkar proizvedel.

def moderated_chatbot(user_input: str) -> str:
    """Klepetalni bot z moderiranjem vhodov IN izhodov."""
    moderator = ContentModerator()

    # 1. Moderiraj vhod
    input_ok, input_details = moderator.moderate(user_input)
    if not input_ok:
        return (f"Vaše sporočilo je bilo blokirano: "
                f"{', '.join(input_details['categories'])}")

    # 2. Generiraj odgovor
    response = client.responses.create(
        model="gpt-5.6-terra",
        instructions="Respond in a professional and safe manner.",
        input=user_input
    )

    # 3. Moderiraj izhod
    output_ok, output_details = moderator.moderate(response.output_text)
    if not output_ok:
        return "Tega odgovora ne morem zagotoviti."

    return response.output_text

# Test
print(moderated_chatbot("What is the capital of France?"))

Paketno moderiranje

Ta dvojni klic doda zakasnitev, kar je v pogovoru sprejemljivo, postane pa prepovedujoče, ko moraš obdelati deset tisoč uporabniških ocen, uvoženih iz datoteke. Za učinkovito moderiranje velikih količin predaj polje neposredno: API obdela vsa besedila v enem samem zahtevku in vrne rezultate v istem vrstnem redu, kar ti omogoča, da jih ponovno povežeš po indeksu.

def moderate_batch(texts: list[str]) -> list[dict]:
    """Moderira več besedil v enem samem zahtevku."""
    results = []

    # API sprejme polje vnosov
    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

# Uporaba
texts = [
    "Hello, how are you?",
    "Great product, I recommend it!",
    "Customer service is excellent.",
]
results = moderate_batch(texts)

Beleženje moderiranja

Odločitev o moderiranju vpliva na uporabnika in prej ali slej jo boš moral utemeljiti – bodisi stranki, ki izpodbija blokado, bodisi regulatorju. Zato sistematično beleži sodbo, ID uporabnika, ocene in odlomek besedila. Raven beleženja razlikuje med obema primeroma: warning za označeno vsebino, ki zasluži človeški pregled, in info za ostalo, ki napaja tvojo statistiko.

import json
import logging
from datetime import datetime

logger = logging.getLogger("moderation")

def moderate_with_log(text: str, user_id: str = "anonymous") -> bool:
    """Moderira in beleži rezultat za revizijo."""
    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

# Uporaba
is_ok = moderate_with_log("Test message", user_id="user-123")

Še eno opozorilo, preden nadaljuješ: moderiranje razvršča vsebino; ne razume namena. Popolnoma vljudno sporočilo, ki poskuša „prebiti” tvojega asistenta, bo šlo skozi vse te filtre, ne da bi bilo enkrat označeno. To je tema naslednje lekcije.

Ključne ugotovitve

  • API za moderiranje je brezplačen – uporabljaj ga sistematično
  • Moderiraj tako vhode (uporabniška vsebina) KOT izhode (odgovori modela)
  • Model omni-moderation-latest pokriva vse kategorije vsebine
  • Beleži vse odločitve o moderiranju za namene revizije
  • Uporabi paketno obdelavo za učinkovito moderiranje velikih količin
  • Moderiranje dopolnjuje sistemska navodila; ne nadomešča jih