Модериране на съдържание в мащаб
На тази страница
Урокът е актуализиран на 3 ноември 2026 г. въз основа на документацията на OpenAI: параметрите
temperatureиtop_pсе приемат само при усилие за разсъждениеnone, докато моделите GPT-5.6 разсъждават по подразбиране (medium). Заявките, които задават тези параметри, трябва следователно да уточняватreasoning={"effort": "none"}(Responses API) илиreasoning_effort="none"(Chat Completions). Източници: Използване на GPT-6 · GPT-5.6 Terra.
Защита на потребителите Ви в продукционна среда
Веднага щом приложението Ви стане публично достъпно, трябва да управлявате неуместното съдържание – както на входа (зловредни подкани), така и на изхода (проблемни отговори). Това изискване за двупосочна проверка често хваща екипите неподготвени. Повечето хора първо мислят за филтриране на това, което потребителите изпращат, но репутационният риск се концентрира върху това, което Вашето приложение публикува от Ваше име. Добре калибриран модел рядко генерира шокиращо съдържание сам по себе си, но може да го направи, ако бъде притиснат – а Вашата марка ще фигурира най-отгоре в скрийншота.
Ще преминем от единично API обаждане към асинхронен конвейер с висока пропускателна способност, мащабирайки стъпка по стъпка.
Първият слой: Moderations API
Moderations API класифицира текста в няколко рискови категории и връща както двоична присъда, така и подробни оценки. То е бързо и безплатно, което го прави естествения първи филтър за всяко публично приложение. Функцията по-долу показва само категориите с оценки над 0.3 – умишлено нисък праг. На този етап искате да видите какво се приближава до границата, а не само какво я преминава.
import openai
client = openai.OpenAI()
def moderate_content(text: str) -> dict:
"""Проверка дали текстът съдържа неуместно съдържание."""
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
},
}
# Пример
result = moderate_content("How do I bake a chocolate cake?")
print(f"Flagged: {result['flagged']}")
В продукционна среда двоичната присъда не е достатъчна. В зависимост от съдържанието и контекста, може да поискате да го разрешите, да го пренапишете, да го блокирате или да го ескалирате до човек – четири различни решения, които трябва да именувате изрично в кода, вместо да импровизирате с булеви стойности. Конвейерът по-долу формализира тези действия, прилага прагове за всяка категория и добавя втори слой за откриване на инжектиране на подкани (prompt injection).
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:
"""Многослоен конвейер за модериране."""
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:
"""Модериране на входно съдържание (подкана от потребителя)."""
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"Inappropriate content: {', '.join(problematic_categories)}",
)
# Откриване на инжектиране на подкани
if self._detect_injection(text):
return ModerationResult(
action=ModerationAction.BLOCK,
reason="Prompt injection attempt detected",
)
return ModerationResult(action=ModerationAction.ALLOW)
def moderate_output(self, response: str) -> ModerationResult:
"""Модериране на изходно съдържание (отговор на LLM)."""
moderation = client.moderations.create(
model="omni-moderation-latest",
input=response,
)
if moderation.results[0].flagged:
return ModerationResult(
action=ModerationAction.BLOCK,
reason="Generated response contains inappropriate content",
)
return ModerationResult(action=ModerationAction.ALLOW)
def _detect_injection(self, text: str) -> bool:
"""Откриване на опити за инжектиране на подкани."""
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)
Прагът от 0.5 за self-harm – по-строг от 0.7, използван за другите категории – илюстрира разсъждението, което трябва да приложите за всеки праг. Тук цената на фалшиво положителен резултат не е нищо спрямо цената на фалшиво отрицателен, затова понижавате летвата. Правете този компромис категория по категория, въз основа на Вашата аудитория, вместо да прилагате еднаква стойност навсякъде.
Откриването на инжекции чрез маркери има едно предупреждение. То хваща наивни опити, които представляват по-голямата част от обема, и нищо повече: леко различно формулиране или преведена версия ще се промъкне. Третирайте го като филтър за шум, а не като защита. Истинската защита срещу инжекции е архитектурна – никога не предоставяйте на модела възможности, които една отвлечена подкана би могла да експлоатира.
Управление на натоварването
При приложение с висок трафик синхронното модериране се превръща в тясно място: всяко съобщение чака своята присъда преди обработката. Асинхронният модератор разединява тези стъпки, като поставя съдържанието в опашка за консумация от множество работници, като същевременно проследява полезна статистика по пътя.
import asyncio
class AsyncModerator:
"""Асинхронно модериране на съдържание за висока пропускателна способност."""
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 "No content moderated."
return (
f"Total: {total} | "
f"Allowed: {self.stats['allowed']} ({self.stats['allowed']/total:.1%}) | "
f"Blocked: {self.stats['blocked']} ({self.stats['blocked']/total:.1%})"
)
Процентът на блокиране, генериран от report, е Вашият основен метрик за калибриране. Ако той внезапно скочи до 15% след работа на 0.5%, съществуват само две обяснения: или сте под координирана атака, или току-що сте счупили праговете си. И в двата случая искате да разберете в рамките на един час, а не на следващия месечен преглед.
Заслужава си да се спомене едно последно ограничение: Moderations API не знае нищо за Вашия бизнес. Съобщение, което е напълно приемливо като цяло, може да нарушава Вашите собствени правила – искане на медицински съвет от банков асистент, опит за получаване на извънмрежова тарифа или заобикаляне на процедура. Контекстуалното модериране добавя този слой, като изпраща съобщението до модел с Вашите изрични правила, но само след като стандартният филтър го е пропуснал.
def contextual_moderation(
text: str,
app_context: str,
business_rules: list[str],
) -> ModerationResult:
"""Контекстно-зависимо модериране, съобразено с приложението."""
pipeline = ModerationPipeline()
standard_result = pipeline.moderate_input(text)
if standard_result.action == ModerationAction.BLOCK:
return standard_result
verification_prompt = (
f"Application context: {app_context}\n\n"
f"Business rules to verify:\n"
+ "\n".join(f"- {r}" for r in business_rules)
+ f"\n\nUser message: {text}\n\n"
"Does the message comply with all rules? "
"Answer yes or no with a brief justification."
)
response = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature requires 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)
Редът на тези две проверки има значение. Безплатният, бърз филтър работи първи, а обаждането към платения модел се случва само за съобщения, които са го преминали. При реален трафик това покрива почти всички съобщения. Да се направи обратното – да се плаща за обаждане до модел за съдържание, което Moderations API би отхвърлило за милисекунди – би било разточително.
Поддържане на защитим запис
Решението за модериране е решение, за което ще носите отговорност, по един или друг начин. Имате нужда от дневник – но такъв, който самият той да не се превръща в проблем. Коментарът в кода подчертава най-важния ред във файла: запишете действието, причината и дължината, никога суровия текст. Съхраняването на потребителски съобщения в лог файл Ви излага на задължения за защита на данните, много по-тежки от предоставяната услуга.
import json
import time
from pathlib import Path
class ModerationLog:
"""Запис на всички решения за модериране за одиторски цели."""
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),
# DO NOT log raw text for privacy
}
with open(self.path, "a") as f:
f.write(json.dumps(entry) + "\n")
Ако все пак трябва да можете да извлечете конкретно съобщение по време на спор, запишете хеш на текста, а не самия текст. Това Ви позволява да потвърдите, че дадено парче съдържание съответства на записано решение, без да запазвате самото съдържание на Ваша страна.
Ключови изводи
- Модерирайте както входовете (подканите), така и изходите (отговорите)
- Използвайте Moderations API като първи, бърз и безплатен слой
- Коригирайте праговете категория по категория въз основа на реалната цена на фалшиво отрицателен резултат
- Добавете откриване на инжекции, знаейки, че то хваща само наивни опити
- Записвайте всички решения за одит, без да съхранявате сурово съдържание