Przejdź do głównej treści
Polski— Wybierz język
Menu

Moderacja treści na dużą skalę

Lekcja 19 z 20 Zaktualizowano 3 listopada 2026 Zaawansowany
Na tej stronie
  1. Ochrona użytkowników w środowisku produkcyjnym
  2. Pierwsza warstwa: API Moderations
  3. Obsługa dużego obciążenia
  4. Prowadzenie obronnych rejestrów
  5. Kluczowe wnioski

Lekcja zaktualizowana 3 listopada 2026 na podstawie dokumentacji OpenAI: parametry temperature i top_p są akceptowane wyłącznie przy wysiłku rozumowania (reasoning effort) ustawionym na none, podczas gdy modele GPT-5.6 domyślnie przeprowadzają rozumowanie (medium). Wywołania ustawiające te parametry muszą zatem określać reasoning={"effort": "none"} (Responses API) lub reasoning_effort="none" (Chat Completions). Źródła: Using GPT-6 · GPT-5.6 Terra.

Ochrona użytkowników w środowisku produkcyjnym

Gdy tylko Twoja aplikacja trafi do użytkowników, musisz radzić sobie z nieodpowiednimi treściami – zarówno po stronie wejścia (złośliwe prompty), jak i wyjścia (problemowe odpowiedzi). Ten dwukierunkowy wymóg często zaskakuje zespoły. Większość osób myśli najpierw o filtrowaniu tego, co wysyłają użytkownicy, ale ryzyko reputacyjne koncentruje się na tym, co Twoja aplikacja publikuje w Twoim imieniu. Dobrze dostosowany model rzadko generuje szokujące treści z własnej inicjatywy, ale może to zrobić pod presją – a Twoje logo znajdzie się na górze zrzutu ekranu.

Przejdziemy od pojedynczego wywołania API do wysokowydajnego potoku asynchronicznego, skalując go krok po kroku.

Pierwsza warstwa: API Moderations

API Moderations klasyfikuje tekst w kilku kategoriach ryzyka i zwraca zarówno werdykt binarny, jak i szczegółowe wyniki. Jest szybkie i darmowe, co czyni je naturalnym pierwszym filtrem dla każdej publicznej aplikacji. Poniższa funkcja wyświetla tylko kategorie z wynikiem powyżej 0,3 – jest to celowo niski próg. Na tym etapie chcesz widzieć, co zbliża się do granicy, a nie tylko to, co ją przekracza.

import openai

client = openai.OpenAI()

def moderate_content(text: str) -> dict:
    """Sprawdź, czy tekst zawiera nieodpowiednie treści."""
    response = client.moderations.create(
        model="omni-moderation-latest",
        input=text,
    )

    result = response.results[0]
    return {
        "flagged": result.flagged,
        "categories": {
            cat: score
            for cat, score in result.category_scores.__dict__.items()
            if score > 0.3
        },
    }

# Przykład
result = moderate_content("Jak upiec ciasto czekoladowe?")
print(f"Oflagowane: {result['flagged']}")

W środowisku produkcyjnym binarny werdykt nie wystarczy. W zależności od treści i kontekstu możesz chcieć ją przepuścić, przeredagować, zablokować lub eskalować do człowieka – to cztery odrębne decyzje, które powinieneś wyraźnie nazwać w kodzie, zamiast improwizować za pomocą wartości logicznych. Poniższy potok formalizuje te działania, stosuje progi dla każdej kategorii i dodaje drugą warstwę wykrywania iniekcji promptów.

from enum import Enum
from dataclasses import dataclass

class ModerationAction(Enum):
    ALLOW = "allow"
    MODIFY = "modify"
    BLOCK = "block"
    ESCALATE = "escalate"

@dataclass
class ModerationResult:
    action: ModerationAction
    reason: str | None = None
    modified_content: str | None = None

class ModerationPipeline:
    """Wielowarstwowy potok moderacji."""

    def __init__(self, thresholds: dict | None = None):
        self.thresholds = thresholds or {
            "harassment": 0.7,
            "hate": 0.7,
            "self-harm": 0.5,
            "sexual": 0.7,
            "violence": 0.7,
        }

    def moderate_input(self, text: str) -> ModerationResult:
        """Moderuj treści wejściowe (prompt użytkownika)."""
        moderation = client.moderations.create(
            model="omni-moderation-latest",
            input=text,
        )

        result = moderation.results[0]
        if result.flagged:
            problematic_categories = [
                cat for cat, flagged in result.categories.__dict__.items()
                if flagged
            ]
            return ModerationResult(
                action=ModerationAction.BLOCK,
                reason=f"Niewłaściwa treść: {', '.join(problematic_categories)}",
            )

        # Wykrywanie iniekcji promptów
        if self._detect_injection(text):
            return ModerationResult(
                action=ModerationAction.BLOCK,
                reason="Wykryto próbę iniekcji promptu",
            )

        return ModerationResult(action=ModerationAction.ALLOW)

    def moderate_output(self, response: str) -> ModerationResult:
        """Moderuj treści wyjściowe (odpowiedź LLM)."""
        moderation = client.moderations.create(
            model="omni-moderation-latest",
            input=response,
        )

        if moderation.results[0].flagged:
            return ModerationResult(
                action=ModerationAction.BLOCK,
                reason="Wygenerowana odpowiedź zawiera niewłaściwe treści",
            )

        return ModerationResult(action=ModerationAction.ALLOW)

    def _detect_injection(self, text: str) -> bool:
        """Wykryj próby iniekcji promptów."""
        markers = [
            "ignore previous instructions",
            "ignore your instructions",
            "forget your guidelines",
            "you are now",
            "new role",
            "system prompt",
            "jailbreak",
        ]
        text_lower = text.lower()
        return any(m in text_lower for m in markers)

Próg 0,5 dla kategorii self-harm – surowszy niż 0,7 stosowane dla innych kategorii – ilustruje rozumowanie, które powinieneś zastosować do każdego progu. Tutaj koszt fałszywie pozytywnego wyniku jest nieporównywalnie mniejszy niż koszt fałszywie negatywnego, więc obniżasz poprzeczkę. Dokonuj tego kompromisu kategoria po kategorii, w oparciu o swoją grupę odbiorców, zamiast stosować jednolitą wartość.

Wykrywanie iniekcji oparte na markerach ma swoje zastrzeżenia. Wyłapuje ono naiwne próby, które stanowią większość ruchu, i nic więcej: nieco inne sformułowanie lub wersja przetłumaczona prześlizgnie się przez filtr. Traktuj to jako filtr szumów, a nie obronę. Prawdziwa ochrona przed iniekcją ma charakter architektoniczny – nigdy nie dawaj modelowi możliwości, które mógłby wykorwać przejęty prompt.

Obsługa dużego obciążenia

W aplikacji o dużym ruchu synchroniczna moderacja staje się wąskim gardłem: każda wiadomość czeka na swój werdykt przed przetworzeniem. Asynchroniczny moderator rozdziela te kroki, kolejkując treści do konsumpcji przez wielu workerów, jednocześnie śledząc przydatne statystyki.

import asyncio

class AsyncModerator:
    """Asynchroniczna moderacja treści dla wysokiej przepustowości."""

    def __init__(self, num_workers: int = 10):
        self.pipeline = ModerationPipeline()
        self.queue: asyncio.Queue = asyncio.Queue()
        self.num_workers = num_workers
        self.stats = {"allowed": 0, "blocked": 0, "escalated": 0}

    async def worker(self):
        while True:
            task = await self.queue.get()
            try:
                result = self.pipeline.moderate_input(task["text"])
                task["callback"](result)

                match result.action:
                    case ModerationAction.ALLOW:
                        self.stats["allowed"] += 1
                    case ModerationAction.BLOCK:
                        self.stats["blocked"] += 1
                    case ModerationAction.ESCALATE:
                        self.stats["escalated"] += 1
            finally:
                self.queue.task_done()

    async def start(self):
        for _ in range(self.num_workers):
            asyncio.create_task(self.worker())

    def report(self) -> str:
        total = sum(self.stats.values())
        if total == 0:
            return "Brak zmoderowanych treści."
        return (
            f"Razem: {total} | "
            f"Dozwolone: {self.stats['allowed']} ({self.stats['allowed']/total:.1%}) | "
            f"Zablokowane: {self.stats['blocked']} ({self.stats['blocked']/total:.1%})"
        )

Wskaźnik blokad generowany przez report to Twój główny metryka kalibracyjna. Jeśli nagle skoczy do 15% po działaniu na poziomie 0,5%, istnieją tylko dwa wyjaśnienia: jesteś pod skoordynowanym atakiem lub właśnie zepsułeś swoje progi. W obu przypadkach chcesz dowiedzieć się o tym w ciągu godziny, a nie podczas kolejnego miesięcznego przeglądu.

Warto wspomnieć o jednym ostatnim ograniczeniu: API Moderations nie wie nic o Twoim biznesie. Wiadomość całkowicie akceptowalna ogólnie może naruszać Twoje własne zasady – np. proszenie asystenta bankowego o poradę medyczną, próba uzyskania stawki poza siecią lub obejście procedury. Moderacja kontekstowa dodaje tę warstwę, przesyłając wiadomość do modelu z Twoimi wyraźnymi zasadami, ale dopiero po tym, jak standardowy filtr ją przepuści.

def contextual_moderation(
    text: str,
    app_context: str,
    business_rules: list[str],
) -> ModerationResult:
    """Moderacja świadoma kontekstu, dostosowana do aplikacji."""
    pipeline = ModerationPipeline()
    standard_result = pipeline.moderate_input(text)

    if standard_result.action == ModerationAction.BLOCK:
        return standard_result

    verification_prompt = (
        f"Kontekst aplikacji: {app_context}\n\n"
        f"Zasady biznesowe do weryfikacji:\n"
        + "\n".join(f"- {r}" for r in business_rules)
        + f"\n\nWiadomość użytkownika: {text}\n\n"
        "Czy wiadomość jest zgodna ze wszystkimi zasadami? "
        "Odpowiedz tak lub nie, dodając krótkie uzasadnienie."
    )

    response = client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # temperature wymaga effort none
        input=verification_prompt,
        max_output_tokens=100,
        temperature=0.0,
    )

    if "no" in response.output_text.lower()[:10]:
        return ModerationResult(
            action=ModerationAction.BLOCK,
            reason=response.output_text,
        )

    return ModerationResult(action=ModerationAction.ALLOW)

Kolejność tych dwóch sprawdzeń ma znaczenie. Darmowy, szybki filtr działa pierwszy, a wywołanie płatnego modelu następuje tylko dla wiadomości, które go przeszły. Przy rzeczywistym ruchu obejmuje to niemal wszystkie wiadomości. Zrobienie tego odwrotnie – płacenie za wywołanie modelu dla treści, które API Moderations odrzuciłoby w milisekundach – byłoby marnotrawstwem.

Prowadzenie obronnych rejestrów

Decyzja moderacyjna to decyzja, z której będziesz rozliczany, tak czy inaczej. Potrzebujesz logów – ale takich, które same nie staną się problemem. Komentarz w kodzie wskazuje najważniejszą linię w pliku: zapisz akcję, powód i długość, nigdy surowy tekst. Przechowywanie wiadomości użytkowników w pliku logów naraża Cię na obowiązki związane z ochroną danych znacznie cięższe niż sama świadczona usługa.

import json
import time
from pathlib import Path

class ModerationLog:
    """Loguj wszystkie decyzje moderacyjne do celów audytowych."""

    def __init__(self, log_path: str = "logs/moderation.jsonl"):
        self.path = Path(log_path)
        self.path.parent.mkdir(parents=True, exist_ok=True)

    def record(
        self,
        text: str,
        result: ModerationResult,
        source: str = "input",
    ):
        entry = {
            "timestamp": time.time(),
            "source": source,
            "action": result.action.value,
            "reason": result.reason,
            "text_length": len(text),
            # NIE loguj surowego tekstu ze względu na prywatność
        }

        with open(self.path, "a") as f:
            f.write(json.dumps(entry) + "\n")

Jeśli nadal musisz móc odzyskać konkretną wiadomość podczas sporu, zaloguj hash tekstu zamiast samego tekstu. Pozwala to potwierdzić, że dana treść odpowiada zarejestrowanej decyzji, bez przechowywania samej treści po Twojej stronie.

Kluczowe wnioski

  • Moderuj zarówno dane wejściowe (prompty), jak i wyjściowe (odpowiedzi)
  • Używaj API Moderations jako pierwszej, szybkiej i darmowej warstwy
  • Dostosowuj progi kategoria po kategorii w oparciu o rzeczywisty koszt błędu negatywnego
  • Dodaj wykrywanie iniekcji, wiedząc, że łapie ono tylko naiwne próby
  • Loguj wszystkie decyzje do audytu, nie przechowując surowych treści