Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Tartalommoderálás az API-val

19. lecke 22 közül Frissítve 2026. november 3. Fejlesztő
Ezen az oldalon
  1. Tartalommoderálás az API-val
  2. A Moderációs API
  3. Moderációs kategóriák
  4. Teljes moderációs folyamat
  5. Kötegelt moderálás
  6. Moderációs naplózás
  7. Főbb megállapítások

Frissítve: 2026. november 3. az OpenAI Moderation útmutatója alapján: az illicit és az illicit/violent kategóriák hiányoztak a listából és a kódból az omni-moderation-latest modell esetében. Forrás: Moderation.

Tartalommoderálás az API-val

Az OpenAI Moderációs API-ja automatikusan észleli a nem megfelelő tartalmakat. Ez egy ingyenes, nélkülözhetetlen eszköz minden olyan alkalmazáshoz, amely felhasználó által generált tartalmat fogad be. Az előző leckében megtanultad, hogyan írj egyedi szűrőket; ez a lecke egy betanított osztályozót ad a kezedbe, amely észreveszi azt, amit a reguláris kifejezések sosem fognak: burkolt fenyegetéseket, közvetett sértéseket és implicit megfogalmazásokat.

A Moderációs API

A hívás szándékosan minimalista: egy modell, egy szöveg, és egy eredmény, amely egy boolean értékre redukálódik. A flagged mező válaszol a bináris kérdésre: „Sérti ez a tartalom a használati szabályzatot?“, míg a categories részletezi, hogy melyiket. Mivel ez a végpont ingyenes, nincs gazdasági oka kihagyni, még nagy forgalom esetén sem.

from openai import OpenAI
client = OpenAI()

# A Moderációs API INGYENES
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}")

# Eredmény:
# Content flagged: False
# Categories: Categories(harassment=False, hate=False, ...)

Moderációs kategóriák

A boolean érték mögött egy finomhangolt rács rejlik. A modell kategóriánkénti döntést hoz – zaklatás, fenyegető zaklatás, gyűlölet, fenyegető gyűlölet, tiltott cselekményekre vonatkozó utasítások (erőszakkal vagy anélkül), önkárosítás annak változataival (utasítások és szándék), szexuális tartalom, kiskorúakat érintő szexuális tartalom, erőszak és grafikus erőszak –, valamint minden egyes kategóriához 0,0 és 1,0 közötti megbízhatósági pontszámot rendel.

Ezek a pontszámok fontosabbak a bináris döntésnél, ha hangolni szeretnéd a szabályzatodat. Egy professzionális fórumplatform például 0,3-as küszöbértéknél blokkolhatja a zaklatást, míg egy fikciós szolgáltatás elfogadhat 0,7-es értéket az erőszaknál. Az alábbi függvény mindkét szintű betekintést biztosítja: a ténylegesen kiváltott kategóriákat és a nyers pontszámokat a saját küszöbértékeidhez.

def analyze_moderation(text: str) -> dict:
    """Részletes moderációs elemzés."""
    moderation = client.moderations.create(
        model="omni-moderation-latest",
        input=text
    )

    result = moderation.results[0]

    # Elérhető kategóriák
    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,
    }

    # Megbízhatósági pontszámok (0.0 és 1.0 között)
    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()},
    }

# Teszt
result = analyze_moderation("Hello everyone!")
print(f"Flagged: {result['flagged']}")
print(f"Scores: {result['main_scores']}")

Teljes moderációs folyamat

Felhasználói bemenetek moderálása

Ágyazzuk ezt a hívást egy újrahasználható komponensbe. A ContentModerator egy explicit párost ad vissza – elfogadható vagy sem, az indokkal együtt –, nem pedig egy nyers objektumot, amit minden hívónak újra kellene értelmeznie. Fontos a kategóriák érthető nyelvre fordítása: ez az a szókincs, amely megjelenik a felületeden és a naplókban, és érthetőnek kell lennie az emberi moderátorok számára, akik átveszik az ügyet.

class ContentModerator:
    """Tartalommoderátor alkalmazásokhoz."""

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

    def moderate(self, text: str) -> tuple[bool, dict]:
        """Moderálja a szöveget. Visszaadja: (elfogadható, részletek)."""
        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("zaklatás")
            if result.categories.hate:
                categories.append("gyűlöletbeszéd")
            if result.categories.sexual:
                categories.append("szexuális tartalom")
            if result.categories.violence:
                categories.append("erőszak")
            if result.categories.self_harm:
                categories.append("önkárosítás")

            return False, {
                "reason": "Nem megfelelő tartalom észlelve",
                "categories": categories
            }

        return True, {"reason": "A tartalom elfogadható"}

    def moderate_conversation(self, messages: list[str]) -> list[dict]:
        """Üzenetek listájának moderálása."""
        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

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

Integráció az API folyamatba

A moderálás mindkét oldalról keretezi a hívást. A bemenet szűrése elkerüli, hogy olyan tartalom generálásáért fizess, amelyet amúgy is elutasítanál; a kimenet szűrése pedig megvéd az olyan esetektől, amikor a modellt ügyesen provokálva maga is valami elfogadhatatlant produkál. Figyeld meg a kezelés különbségét: bemenet esetén közölheted a felhasználóval, mit észleltél, mivel ő írta; kimenet esetén az üzenet marad homályos, mert a részletezés azt jelentené, hogy leírod, amit a modell éppen előállított.

def moderated_chatbot(user_input: str) -> str:
    """Chatbot a bemenetek ÉS a kimenetek moderálásával."""
    moderator = ContentModerator()

    # 1. Bemenet moderálása
    input_ok, input_details = moderator.moderate(user_input)
    if not input_ok:
        return (f"Üzeneted blokkolva lett: "
                f"{', '.join(input_details['categories'])}")

    # 2. Válasz generálása
    response = client.responses.create(
        model="gpt-5.6-terra",
        instructions="Respond in a professional and safe manner.",
        input=user_input
    )

    # 3. Kimenet moderálása
    output_ok, output_details = moderator.moderate(response.output_text)
    if not output_ok:
        return "Nem tudom megadni ezt a választ."

    return response.output_text

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

Kötegelt moderálás

Ez a dupla hívás késleltetést okoz, ami beszélgetés esetén elfogadható, de tiltó tényezővé válik, amikor tízezer ügyfélvéleményt kell feldolgoznod egy fájlból importálva. A nagy mennyiségek hatékony moderálásához adj át közvetlenül egy tömböt: az API egyetlen kérésben dolgozza fel az összes szöveget, és ugyanabban a sorrendben adja vissza az eredményeket, lehetővé téve az index szerinti újraösszerendelést.

def moderate_batch(texts: list[str]) -> list[dict]:
    """Több szöveg moderálása egyetlen kérésben."""
    results = []

    # Az API elfogadja a bemenetek tömbjét
    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

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

Moderációs naplózás

Egy moderációs döntés érinti a felhasználót, és előbb-utóbb igazolnod kell azt – legyen szó egy blokkolást vitató ügyfélről vagy egy szabályozó hatóságról. Ezért szisztematikusan naplózd az ítéletet, a felhasználói azonosítót, a pontszámokat és a szövegrészletet. A naplózási szint megkülönbözteti a két esetet: warning a megjelölt tartalmaknál, amelyek emberi felülvizsgálatot érdemelnek, és info a többinél, amelyek a statisztikáidat táplálják.

import json
import logging
from datetime import datetime

logger = logging.getLogger("moderation")

def moderate_with_log(text: str, user_id: str = "anonymous") -> bool:
    """Moderál és naplózza az eredményt auditálás céljából."""
    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

# Használat
is_ok = moderate_with_log("Test message", user_id="user-123")

Egy utolsó figyelmeztetés, mielőtt továbblépünk: a moderálás osztályozza a tartalmat, de nem érti a szándékot. Egy tökéletesen udvarias üzenet, amely megpróbálja kijátszani az asszisztensedet, minden szűrőn átmegy anélkül, hogy valaha is megjelölnék. Ez lesz a következő lecke témája.

Főbb megállapítások

  • A Moderációs API ingyenes – használd szisztematikusan
  • Moderáld mind a bemeneteket (felhasználói tartalom), mind a kimeneteket (modellválaszok)
  • Az omni-moderation-latest modell lefedi az összes tartalmi kategóriát
  • Naplózz minden moderációs döntést auditálás céljából
  • Használj kötegelt feldolgozást a nagy mennyiségek hatékony moderálásához
  • A moderálás kiegészíti a rendszerutasításokat, de nem helyettesíti azokat