Il-moderazzjoni tal-kontenut fuq skala kbira
F'din il-paġna
Lezzjoni aġġornata fit-3 ta’ Novembru 2026 ibbażata fuq id-dokumentazzjoni ta’ OpenAI:
temperatureutop_phuma aċċettati biss b’sforz ta’ raġunar ta’none, filwaqt li l-mudelli GPT-5.6 jirraġunaw b’mod awtomatiku (medium). Għalhekk, is-sejħiet li jistabbilixxu dawn il-parametri jridu jispeċifikawreasoning={"effort": "none"}(Responses API) jewreasoning_effort="none"(Chat Completions). Sorsi: L-użu ta’ GPT-6 · GPT-5.6 Terra.
Il-protezzjoni tal-utenti tiegħek fil-produzzjoni
Hekk kif l-applikazzjoni tiegħek tmur live, trid timmaniġġja kontenut mhux xieraq—kemm fuq l-input (prompts malizzjużi) kif ukoll fuq l-output (risposti problematiċi). Dan ir-rekwiżit bid-direzzjonijiet doppji spiss iħalli lit-timijiet sorpriżi. Ħafna nies jaħsbu l-ewwel dwar il-filtrar ta’ dak li jibgħatu l-utenti, iżda r-riskju għar-reputazzjoni jiffoka fuq dak li l-applikazzjoni tiegħek tippubblika taħt ismek. Mudell allinjat sewwa rari jiġġenera kontenut xokkanti waħdu, iżda jista’ jagħmel hekk meta jkun imħeġġeġ—u l-marka tiegħek tidher fil-quċċata tas-screenshot.
Se nimxu minn sejħa API waħda għal pipeline asinkrona b’tħaddim għoli, u nkabru pass pass.
L-ewwel saff: l-API tal-Moderazzjoni
L-API tal-Moderazzjoni tikklassifika t-test f’diversi kategoriji ta’ riskju u tirritorna kemm verdett binarju kif ukoll punteġġi dettaljati. Hija mgħaġġla u bla ħlas, u għalhekk hija l-ewwel filtru naturali għal kwalunkwe applikazzjoni pubblika. Il-funzjoni hawn taħt turi biss kategoriji b’punteġġi ‘l fuq minn 0.3—limitu deliberatament baxx. F’dan l-istadju, trid tara x’qed joqrob lejn il-linja, mhux biss dak li jaqbiżha.
import openai
client = openai.OpenAI()
def moderate_content(text: str) -> dict:
"""Iċċekkja jekk it-test fihx kontenut mhux xieraq."""
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
},
}
# Eżempju
result = moderate_content("How do I bake a chocolate cake?")
print(f"Flagged: {result['flagged']}")
Fil-produzzjoni, verdett binarju mhuwiex biżżejjed. Skont il-kontenut u l-kuntest, tista’ trid tippermettih, terġa’ tiktbu, timblukkah, jew tgħollieh għal bniedem—erba’ deċiżjonijiet distinti li għandek tsemmi b’mod espliċitu fil-kodiċi minflok ma timprovvisa b’booleans. Il-pipeline hawn taħt tifformalizza dawn l-azzjonijiet, tapplika limiti għal kull kategorija, u żżid it-tieni saff għad-detezzjoni tal-injezzjoni tal-prompt.
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 ta' moderazzjoni b'saffi multipli."""
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:
"""Immodera l-kontenut tal-input (prompt tal-utent)."""
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"Kontenut mhux xieraq: {', '.join(problematic_categories)}",
)
# Detezzjoni tal-injezzjoni tal-prompt
if self._detect_injection(text):
return ModerationResult(
action=ModerationAction.BLOCK,
reason="Tentattiv ta' injezzjoni tal-prompt skopert",
)
return ModerationResult(action=ModerationAction.ALLOW)
def moderate_output(self, response: str) -> ModerationResult:
"""Immodera l-kontenut tal-output (risposta LLM)."""
moderation = client.moderations.create(
model="omni-moderation-latest",
input=response,
)
if moderation.results[0].flagged:
return ModerationResult(
action=ModerationAction.BLOCK,
reason="Ir-risposta ġġenerata fiha kontenut mhux xieraq",
)
return ModerationResult(action=ModerationAction.ALLOW)
def _detect_injection(self, text: str) -> bool:
"""Skopri tentattivi ta' injezzjoni tal-prompt."""
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)
Il-limitu ta’ 0.5 għal self-harm—aktar strett mill-0.7 użat għal kategoriji oħra—juri r-raġunar li għandek tapplika għal kull limitu. Hawnhekk, l-ispiża ta’ pożittiv falz hija ferm inqas mill-ispiża ta’ negattiv falz, allha tnaqqas il-livell. Agħmel dan il-kompromess kategorija b’kategorija, ibbażat fuq l-udjenza tiegħek, minflok ma tapplika valur uniformi.
Id-detezzjoni tal-injezzjoni bbażata fuq markaturi għandha avvertenza. Taqbad tentattivi naivi, li jirrappreżentaw il-biċċa l-kbira tal-volum, u xejn aktar: frażi ftit differenti jew verżjoni tradotta tgħaddi mingħajr ma tiġi skoperta. Itrattaha bħala filtru tan-niżla, mhux bħala difiża. Il-protezzjoni reali kontra l-injezzjoni hija arkitettonika—qatt ma tagħti lill-mudell kapaċitajiet li prompt maħtuf jista’ jisfrutta.
L-immaniġġjar tat-tagħbija
Fuq applikazzjoni b’traffiku għoli, il-moderazzjoni sinkrona ssir ostaklu: kull messaġġ jistenna l-verdett tiegħu qabel ma jiġi pproċessat. Moderatur asinkronu jissepara dawn il-passi billi jqiegħed il-kontenut f’queue biex jiġi kkunsmat minn ħaddiema multipli, filwaqt li jsegwi wkoll statistiċi utli matul it-triq.
import asyncio
class AsyncModerator:
"""Immodera l-kontenut b'mod asinkronu għal throughput għoli."""
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 "L-ebda kontenut ma ġie mmoderat."
return (
f"Total: {total} | "
f"Permess: {self.stats['allowed']} ({self.stats['allowed']/total:.1%}) | "
f"Imblukkat: {self.stats['blocked']} ({self.stats['blocked']/total:.1%})"
)
Ir-rata ta’ blokk prodotta minn report hija l-metrika primarja tal-kalibrazzjoni tiegħek. Jekk f’daqqa waħda tiżdied għal 15% wara li kienet taħdem fuq 0.5%, hemm biss żewġ spjegazzjonijiet possibbli: qed tgħaddi minn attakk koordinat, jew għaddejt il-limiti tiegħek. Fi kwalunkwe każ, trid tkun taf fi żmien siegħa, mhux fir-reviżjoni mensili li jmiss.
Limitazzjoni finali tisħoq li tiġi msemmija: l-API tal-Moderazzjoni ma taf xejn dwar in-negozju tiegħek. Messaġġ li huwa perfettament aċċettabbli ġeneralment jista’ jikser ir-regoli tiegħek stess—li titlob parir mediku minn assistent bankarju, li tipprova tikseb rata off-grid, jew li tevadi proċedura. Il-moderazzjoni kuntestwali żżid dan is-saff billi tissottometti l-messaġġ lil mudell bir-regoli espliċiti tiegħek, iżda biss wara li l-filtru standard ikun ħallieh jgħaddi.
def contextual_moderation(
text: str,
app_context: str,
business_rules: list[str],
) -> ModerationResult:
"""Moderazzjoni sensittiva għall-kuntest adattata għall-applikazzjoni."""
pipeline = ModerationPipeline()
standard_result = pipeline.moderate_input(text)
if standard_result.action == ModerationAction.BLOCK:
return standard_result
verification_prompt = (
f"Kuntest tal-applikazzjoni: {app_context}\n\n"
f"Regoli tan-negozju li għandhom jiġu vverifikati:\n"
+ "\n".join(f"- {r}" for r in business_rules)
+ f"\n\nMessaġġ tal-utent: {text}\n\n"
"Il-messaġġ jikkonforma mar-regoli kollha? "
"Wieġeb iva jew le b'ġustifikazzjoni qasira."
)
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)
L-ordni ta’ dawn iż-żewġ verifiki huwa importanti. Il-filtru bla ħlas u mgħaġġel jimxi l-ewwel, u s-sejħa tal-mudell imħallas iseħħ biss għall-messaġġi li jgħaddu minnu. Fuq traffiku reali, dan ikopri kważi l-messaġġi kollha. Li tagħmel il-maqlub—li tħallas għal sejħa ta’ mudell fuq kontenut li l-API tal-Moderazzjoni kien jirrifjuta f’millisekondi—ikun ħela.
Iż-żamma ta’ rekord difendibbli
Deċiżjoni ta’ moderazzjoni hija deċiżjoni li se titqabad responsabbli għaliha, b’xi mod jew ieħor. Għandek bżonn reġistru—iżda wieħed li ma jsirx problema huwa stess. Il-kumment fil-kodiċi jenfasizza l-aktar linja importanti fil-fajl: irreġistra l-azzjoni, ir-raġuni, u t-tul, qatt mhux it-test raw. Il-ħażna tal-messaġġi tal-utenti f’fajl tar-reġistru tesponik għal obbligi ta’ protezzjoni tad-data ferm aktar tqal mis-servizz ipprovdut.
import json
import time
from pathlib import Path
class ModerationLog:
"""Irreġistra d-deċiżjonijiet kollha tal-moderazzjoni għal skopijiet ta' awditjar."""
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")
Jekk xorta waħda trid tkun tista’ tirkupra messaġġ speċifiku waqt tilwima, irreġistra hash tat-test minflok it-test innifsu. Dan jippermettilek tikkonferma li biċċa kontenut partikolari taqbel ma’ deċiżjoni rreġistrata mingħajr ma żżomm il-kontenut fuq in-naħa tiegħek.
Punti Ewlenin
- Immodera kemm l-inputs (prompts) kif ukoll l-outputs (risposti)
- Uża l-API tal-Moderazzjoni bħala l-ewwel saff tiegħek, mgħaġġel u bla ħlas
- Aġġusta l-limiti kategorija b’kategorija ibbażat fuq l-ispiża reali ta’ negattiv falz
- Żid id-detezzjoni tal-injezzjoni billi tkun taf li taqbad biss tentattivi naivi
- Irreġistra d-deċiżjonijiet kollha għall-awditjar mingħajr ma taħżen kontenut raw