Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

Il-moderazzjoni tal-kontenut fuq skala kbira

Lezzjoni 19 / 20 Aġġornat 3 ta’ Novembru 2026 Avvanzat
F'din il-paġna
  1. Il-protezzjoni tal-utenti tiegħek fil-produzzjoni
  2. L-ewwel saff: l-API tal-Moderazzjoni
  3. L-immaniġġjar tat-tagħbija
  4. Iż-żamma ta’ rekord difendibbli
  5. Punti Ewlenin

Lezzjoni aġġornata fit-3 ta’ Novembru 2026 ibbażata fuq id-dokumentazzjoni ta’ OpenAI: temperature u top_p huma 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ċifikaw reasoning={"effort": "none"} (Responses API) jew reasoning_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