Salt la conținutul principal
Română— Alege o limbă
Meniu

Moderarea conținutului la scară largă

Lecția 19 din 20 Actualizată 3 noiembrie 2026 Avansat
Pe această pagină
  1. Protejarea utilizatorilor în producție
  2. Primul strat: API-ul Moderations
  3. Gestionarea sarcinii
  4. Păstrarea unei înregistrări defensabile
  5. Puncte cheie

Lecție actualizată la 3 noiembrie 2026 pe baza documentației OpenAI: parametrii temperature și top_p sunt acceptați doar cu un efort de raționament de none, în timp ce modelele GPT-5.6 raționează implicit (medium). Apelurile care setează acești parametri trebuie, prin urmare, să specifice reasoning={"effort": "none"} (API-ul Responses) sau reasoning_effort="none" (Chat Completions). Surse: Utilizarea GPT-6 · GPT-5.6 Terra.

Protejarea utilizatorilor în producție

Imediat ce aplicația dumneavoastră devine activă, trebuie să gestionați conținutul inadecvat – atât la intrare (prompturi malițioase), cât și la ieșire (răspunsuri problematice). Această cerință bidirecțională prinde adesea echipele nepregătite. Majoritatea se gândesc mai întâi la filtrarea a ceea ce trimit utilizatorii, dar riscul de reputație se concentrează asupra a ceea ce aplicația dumneavoastră publică sub numele dvs. Un model bine aliniat generează rareori conținut șocant de la sine, dar o poate face dacă este împins în această direcție – iar brandul dumneavoastră apare în partea de sus a capturii de ecran.

Vom trece de la un singur apel API la un pipeline asincron de throughput ridicat, scalând pas cu pas.

Primul strat: API-ul Moderations

API-ul Moderations clasifică textul în mai multe categorii de risc și returnează atât un verdict binar, cât și scoruri detaliate. Este rapid și gratuit, ceea ce îl face filtrul inițial natural pentru orice aplicație publică. Funcția de mai jos expune doar categoriile cu scoruri peste 0,3 – un prag deliberat scăzut. În această etapă, doriți să vedeți ce se apropie de linie, nu doar ce o traversează.

import openai

client = openai.OpenAI()

def moderate_content(text: str) -> dict:
    """Verifică dacă textul conține conținut inadecvat."""
    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
        },
    }

# Exemplu
result = moderate_content("How do I bake a chocolate cake?")
print(f"Flagged: {result['flagged']}")

În producție, un verdict binar nu este suficient. În funcție de conținut și context, s-ar putea să doriți să îl permiteți, să îl rescrieți, să îl blocați sau să îl escaladați către un om – patru decizii distincte pe care ar trebui să le numiți explicit în cod, în loc să improvizați cu booleeni. Pipeline-ul de mai jos formalizează aceste acțiuni, aplică praguri per categorie și adaugă un al doilea strat pentru detectarea injectării de prompturi.

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:
    """Pipeline de moderare pe mai multe straturi."""

    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:
        """Moderarea conținutului de intrare (promptul utilizatorului)."""
        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"Conținut inadecvat: {', '.join(problematic_categories)}",
            )

        # Detectarea injectării de prompturi
        if self._detect_injection(text):
            return ModerationResult(
                action=ModerationAction.BLOCK,
                reason="Tentativă de injectare de prompt detectată",
            )

        return ModerationResult(action=ModerationAction.ALLOW)

    def moderate_output(self, response: str) -> ModerationResult:
        """Moderarea conținutului de ieșire (răspunsul LLM)."""
        moderation = client.moderations.create(
            model="omni-moderation-latest",
            input=response,
        )

        if moderation.results[0].flagged:
            return ModerationResult(
                action=ModerationAction.BLOCK,
                reason="Răspunsul generat conține conținut inadecvat",
            )

        return ModerationResult(action=ModerationAction.ALLOW)

    def _detect_injection(self, text: str) -> bool:
        """Detectează tentativele de injectare de prompturi."""
        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)

Pragul de 0,5 pentru self-harm – mai strict decât 0,7 folosit pentru alte categorii – ilustrează raționamentul pe care ar trebui să îl aplicați fiecărui prag. Aici, costul unui fals pozitiv nu se compară cu costul unui fals negativ, așa că coborâți ștacheta. Faceți acest compromis categorie cu categorie, în funcție de publicul dumneavoastră, în loc să aplicați o valoare uniformă.

Detectarea injectării bazată pe markeri vine cu o rezervă. Aceasta prinde tentativele naive, care reprezintă grosul volumului, și nimic mai mult: o formulare ușor diferită sau o versiune tradusă va scăpa. Tratați-o ca pe un filtru de zgomot, nu ca pe o apărare. Protecția reală împotriva injectării este arhitecturală – nu oferiți niciodată modelului capacități pe care un prompt deturnat le-ar putea exploata.

Gestionarea sarcinii

Pe o aplicație cu trafic ridicat, moderarea sincronă devine un gât de sticlă: fiecare mesaj așteaptă verdictul înainte de procesare. Un moderator asincron decuplează acești pași prin punerea în coadă a conținutului pentru consum de către mai mulți lucrători, urmărind în același timp statistici utile pe parcurs.

import asyncio

class AsyncModerator:
    """Moderarea asincronă a conținutului pentru throughput ridicat."""

    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 "Niciun conținut moderat."
        return (
            f"Total: {total} | "
            f"Permise: {self.stats['allowed']} ({self.stats['allowed']/total:.1%}) | "
            f"Blocate: {self.stats['blocked']} ({self.stats['blocked']/total:.1%})"
        )

Rata de blocare produsă de report este metrica dumneavoastră principală de calibrare. Dacă aceasta sare brusc la 15% după ce a rulat la 0,5%, există doar două explicații: sunteți sub un atac coordonat sau tocmai v-ați stricat pragurile. În ambele cazuri, doriți să aflați în decurs de o oră, nu la următoarea revizuire lunară.

O ultimă limitare merită menționată: API-ul Moderations nu știe nimic despre afacerea dumneavoastră. Un mesaj perfect acceptabil în general poate încălca propriile dumneavoastră reguli – solicitarea de sfaturi medicale de la un asistent bancar, încercarea de a obține o tarifare off-grid sau ocolirea unei proceduri. Moderarea contextuală adaugă acest strat prin trimiterea mesajului către un model cu regulile dumneavoastră explicite, dar doar după ce filtrul standard l-a permis să treacă.

def contextual_moderation(
    text: str,
    app_context: str,
    business_rules: list[str],
) -> ModerationResult:
    """Moderare conștientă de context, adaptată aplicației."""
    pipeline = ModerationPipeline()
    standard_result = pipeline.moderate_input(text)

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

    verification_prompt = (
        f"Contextul aplicației: {app_context}\n\n"
        f"Reguli de afaceri de verificat:\n"
        + "\n".join(f"- {r}" for r in business_rules)
        + f"\n\nMesajul utilizatorului: {text}\n\n"
        "Respectă mesajul toate regulile? "
        "Răspundeți da sau nu cu o scurtă justificare."
    )

    response = client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # temperature necesită 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)

Ordinea acestor două verificări contează. Filtrul gratuit și rapid rulează primul, iar apelul modelului plătit are loc doar pentru mesajele care îl trec. În cazul traficului real, aceasta acoperă aproape toate mesajele. A face invers – a plăti pentru un apel de model pentru conținut pe care API-ul Moderations l-ar fi respins în milisecunde – ar fi risipitor.

Păstrarea unei înregistrări defensabile

O decizie de moderare este o decizie pentru care veți fi tras la răspundere, într-un fel sau altul. Aveți nevoie de un jurnal – dar unul care să nu devină el însuși o problemă. Comentariul din cod evidențiază cea mai importantă linie din fișier: înregistrați acțiunea, motivul și lungimea, niciodată textul brut. Stocarea mesajelor utilizatorilor într-un fișier jurnal vă expune la obligații de protecție a datelor mult mai grele decât serviciul furnizat.

import json
import time
from pathlib import Path

class ModerationLog:
    """Înregistrează toate deciziile de moderare în scopuri de audit."""

    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),
            # NU înregistrați textul brut din motive de confidențialitate
        }

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

Dacă totuși trebuie să puteți recupera un mesaj specific în timpul unei dispute, înregistrați un hash al textului în loc de textul însuși. Acest lucru vă permite să confirmați că o anumită bucată de conținut corespunde unei decizii înregistrate fără a păstra conținutul de partea dumneavoastră.

Puncte cheie

  • Moderați atât intrările (prompturi), cât și ieșirile (răspunsuri)
  • Utilizați API-ul Moderations ca primul strat, rapid și gratuit
  • Ajustați pragurile categorie cu categorie în funcție de costul real al unui fals negativ
  • Adăugați detectarea injectării știind că aceasta prinde doar tentativele naive
  • Înregistrați toate deciziile pentru audit fără a stoca conținutul brut