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

Konformità u Traċċa tal-Awditjar

Lezzjoni 22 / 22 Aġġornat 29 ta’ Lulju 2026 Zviluppatur
F'din il-paġna
  1. Konformità u Traċċa tal-Awditjar
  2. Għaliex Traċċa tal-Awditjar?
  3. Struttura ta’ Reġistru tal-Awditjar
  4. Sistema Sħiħa tal-Awditjar
  5. Mistoqsijiet tal-Awditjar
  6. Retenzjoni u Arkivjar
  7. L-Att Ewropew dwar l-AI: X’Jinbidel
  8. Lista ta’ Verifika tal-Konformità
  9. Punti Ewlenin
  10. Ittestja l-Għarfien Tiegħek

Konformità u Traċċa tal-Awditjar

Għal applikazzjonijiet tal-AI fil-produzzjoni, it-traċċabbiltà hija essenzjali. Traċċa sħiħa tal-awditjar tipproteġik waqt spezzjoni, tilwima, jew inċident. Din il-lezzjoni turi kif timplimenta sistema robusta tal-awditjar, li tikkonkludi l-kors billi tgħaqqad kollox li bnejt sa issa—reġistrazzjoni (logging), moderazzjoni, u protezzjoni tad-data—f’qafas wieħed difendibbli.

Għaliex Traċċa tal-Awditjar?

Erba’ ħtiġijiet distinti jiltaqgħu fl-istess infrastruttura. L-ewwel, konformità regolatorja: il-GDPR, l-Att Ewropew dwar l-AI, u l-istandards tal-industrija jitolbuk kollha turi x’jagħmel is-sistema tiegħek, u dimostrazzjoni mingħajr logs ma tiswi xejn. It-tieni, traċċabbiltà fis-sens strett—li tkun taf min għamel xiex, meta, b’liema riżultat, anke sitt xhur wara. Id-debugging jibbenefika minn dan kuljum, peress li biex tifhem imġiba mhux mistennija tal-mudell trid tirrikupra l-kundizzjonijiet eżatti tas-sejħa. Fl-aħħar nett, responsabbiltà: id-dokumentazzjoni tad-deċiżjonijiet meħuda mill-AI hija dak li jippermettilek, meta jasal il-waqt, turi li rakkomandazzjoni kkontestata kienet ibbażata fuq proċess ikkontrollat.

Struttura ta’ Reġistru tal-Awditjar

Id-dataclass hawn taħt hija kemm kuntratt kif ukoll struttura tad-data. Tgħaqqad identifikaturi, kuntest tal-applikazzjoni, it-talba, ir-rispons, il-verdett tal-moderazzjoni, u metadata tekniku. Żewġ għażliet jistħoqqilhom attenzjoni. L-identifikatur tal-utent jidher biss f’forma mħassra (hashed), qatt mhux f’test ċar. U l-prompt ma jinħażinx: biss il-hash u t-tul tiegħu. Dan iżomm il-kapaċità tiegħek li tipprova li żewġ sejħat kienu jikkonċernaw l-istess kontenut mingħajr qatt ma toħloq arkivju ta’ dak li kitbu l-utenti tiegħek.

from dataclasses import dataclass, field, asdict
from datetime import datetime
from typing import Optional
import json
import uuid
import hashlib

@dataclass
class AuditRecord:
    """Reġistru tal-awditjar għal sejħa API."""
    # Identifikaturi
    audit_id: str = field(default_factory=lambda: str(uuid.uuid4()))
    timestamp: str = field(
        default_factory=lambda: datetime.now().isoformat()
    )

    # Kuntest
    user_id_hash: str = ""  # Qatt mhux l-ID ċara
    session_id: str = ""
    application: str = ""

    # Talba (l-ebda data sensittiva)
    model: str = ""
    prompt_hash: str = ""  # Hash tal-prompt, mhux il-prompt innifsu
    prompt_length: int = 0

    # Rispons
    response_id: str = ""
    output_length: int = 0
    input_tokens: int = 0
    output_tokens: int = 0

    # Moderazzjoni
    input_flagged: bool = False
    output_flagged: bool = False

    # Metadata
    duration_ms: int = 0
    status: str = "success"
    error: Optional[str] = None

    def to_json(self) -> str:
        return json.dumps(asdict(self), ensure_ascii=False)

Sistema Sħiħa tal-Awditjar

Il-klijent li juża din l-istruttura jgħaqqad il-moderazzjoni tal-input, is-sejħa API, il-moderazzjoni tal-output, u jikteb f’kull każ. Il-kelma importanti hija append-only: il-fajl JSONL jinfetaħ f’modalità ta’ miżjuda (append), qatt ma jiġi miktub mill-ġdid, li hija l-kundizzjoni biex log ikollu valur probatorju. Innota l-mogħdija ta’ dħul immarkat (flagged)—ir-reġistru jinħażen qabel ma titqajjem l-eċċezzjoni, bl-istatus blocked_input. Għalhekk, blokk iħalli traċċa eżatt bħal suċċess, u l-blokk finali except jiggarantixxi li l-ebda żball, minn fejn ikun ġej, ma jaħrab mill-attenzjoni.

import time
from openai import OpenAI

class AuditedClient:
    """Klijent OpenAI b'traċċa tal-awditjar integrata."""

    def __init__(self, application: str, audit_store: str = "audit.jsonl"):
        self.client = OpenAI()
        self.application = application
        self.audit_store = audit_store

    def _hash(self, text: str) -> str:
        """Hash SHA-256 imqassar għall-awditjar."""
        return hashlib.sha256(text.encode()).hexdigest()[:16]

    def _save_audit(self, record: AuditRecord):
        """Jissalva reġistru tal-awditjar (append-only)."""
        with open(self.audit_store, "a", encoding="utf-8") as f:
            f.write(record.to_json() + "\n")

    def create(self, user_id: str, session_id: str,
               model: str, input: str, **kwargs) -> object:
        """Sejħa API b'awditjar awtomatiku."""

        record = AuditRecord(
            user_id_hash=self._hash(user_id),
            session_id=session_id,
            application=self.application,
            model=model,
            prompt_hash=self._hash(input),
            prompt_length=len(input),
        )

        start = time.monotonic()

        try:
            # Moderazzjoni tal-input
            mod = self.client.moderations.create(
                model="omni-moderation-latest",
                input=input
            )
            record.input_flagged = mod.results[0].flagged

            if record.input_flagged:
                record.status = "blocked_input"
                self._save_audit(record)
                raise ValueError("Kontenut tal-input mhux xieraq")

            # Sejħa API
            response = self.client.responses.create(
                model=model,
                input=input,
                **kwargs
            )

            # Moderazzjoni tal-output
            mod_out = self.client.moderations.create(
                model="omni-moderation-latest",
                input=response.output_text
            )
            record.output_flagged = mod_out.results[0].flagged

            # Imla l-metriċi
            record.response_id = response.id
            record.output_length = len(response.output_text)
            record.input_tokens = response.usage.input_tokens
            record.output_tokens = response.usage.output_tokens
            record.duration_ms = round((time.monotonic() - start) * 1000)
            record.status = "success"

            self._save_audit(record)
            return response

        except Exception as e:
            record.duration_ms = round((time.monotonic() - start) * 1000)
            record.status = "error"
            record.error = type(e).__name__
            self._save_audit(record)
            raise

# Użu
audited = AuditedClient(application="support-chatbot")

response = audited.create(
    user_id="[email protected]",
    session_id="sess-abc123",
    model="gpt-5.6-terra",
    input="Kif nirritorna prodott?"
)
print(response.output_text)

F’dan l-eżempju, l-indirizz email mogħti bħala user_id qatt ma jilħaq il-fajl: jiġi mħassar (hashed) hekk kif jinbena r-reġistru. Fajl JSONL jaħdem tajjeb biex tibda u għal istanza waħda; hekk kif proċessi multipli jiktbu parallelament, iddirieġi dan il-fluss lejn database jew kollettur tal-logs.

Mistoqsijiet tal-Awditjar

Log li ma tistax tistaqsih iservi biss biex jokkupa spazju fuq id-diska. Il-qari linja b’linja tal-format JSONL jagħmel l-isfruttament banali, u r-rapport hawn taħt jissintetizza l-perjodu kopert, id-distribuzzjoni bejn suċċessi, żbalji, u blokok, il-konsum tat-tokens, u l-latenza medja. Il-għadd ta’ utenti uniċi jiddependi fuq hashes, li jipprova inċidentalment li log pseudonimizzat jibqa’ perfettament analizzabbli.

import json

def read_audit(file: str = "audit.jsonl") -> list[dict]:
    """Jaqra r-reġistri kollha tal-awditjar."""
    records = []
    try:
        with open(file, "r", encoding="utf-8") as f:
            for line in f:
                if line.strip():
                    records.append(json.loads(line))
    except FileNotFoundError:
        pass
    return records

def audit_report(file: str = "audit.jsonl") -> dict:
    """Jiġġenera rapport tal-awditjar."""
    records = read_audit(file)

    if not records:
        return {"message": "L-ebda reġistru"}

    total = len(records)
    errors = sum(1 for r in records if r["status"] == "error")
    blocked = sum(1 for r in records if r["status"] == "blocked_input")
    tokens_total = sum(
        r.get("input_tokens", 0) + r.get("output_tokens", 0)
        for r in records
    )
    durations = [r["duration_ms"] for r in records if r["duration_ms"] > 0]

    return {
        "period": {
            "start": records[0]["timestamp"],
            "end": records[-1]["timestamp"],
        },
        "total_calls": total,
        "successes": total - errors - blocked,
        "errors": errors,
        "moderation_blocks": blocked,
        "tokens_consumed": tokens_total,
        "avg_latency_ms": round(sum(durations) / max(len(durations), 1)),
        "unique_users": len(set(r["user_id_hash"] for r in records)),
    }

print(json.dumps(audit_report(), indent=2, ensure_ascii=False))

Retenzjoni u Arkivjar

Li żżomm id-data għal dejjem jikkontradixxi l-prinċipju tal-limitazzjoni tal-ħżin; li tħassar kmieni wisq iċaħħdek mill-prova li tista’ tkollok bżonn. Ir-rotazzjoni ssolvi dan id-dilemma: wara tul ta’ żmien li tiddetermina int—disgħin jum hawnhekk—ir-reġistri joħorġu mill-fajl attiv għal arkivju datat, filwaqt li l-log kurrenti jiġi miktub mill-ġdid biss b’dawk riċenti. Skeda din il-funzjoni bħala kompitu perjodiku u allinja retention_days mal-politika vvalidata mill-kunsill legali tiegħek, mhux valur magħżul b’mod każwali.

from datetime import datetime, timedelta
import shutil
import os

def archive_audit(file: str = "audit.jsonl",
                  retention_days: int = 90):
    """Jarkivja u jnaddaf reġistri antiki."""
    records = read_audit(file)
    limit = datetime.now() - timedelta(days=retention_days)

    recent = []
    archives = []

    for record in records:
        date_record = datetime.fromisoformat(record["timestamp"])
        if date_record > limit:
            recent.append(record)
        else:
            archives.append(record)

    if archives:
        # Arkivja dawk antiki
        archive_name = f"audit_archive_{datetime.now().strftime('%Y%m%d')}.jsonl"
        with open(archive_name, "w", encoding="utf-8") as f:
            for record in archives:
                f.write(json.dumps(record, ensure_ascii=False) + "\n")

        # Ikteb mill-ġdid il-fajl prinċipali b'dawk riċenti
        with open(file, "w", encoding="utf-8") as f:
            for record in recent:
                f.write(json.dumps(record, ensure_ascii=False) + "\n")

        print(f"Ġew arkvjati {len(archives)} reġistri f'{archive_name}")
        print(f"Inżammu {len(recent)} reġistri riċenti")

L-Att Ewropew dwar l-AI: X’Jinbidel

L-Att Ewropew dwar l-AI (AI Act) jimponi obbligi bbażati fuq il-livell ta’ riskju tal-applikazzjoni tiegħek. Il-loġika hija gradwali: aktar ma s-sistema tiegħek tiżen fuq il-ħajja tan-nies, aktar ikunu stretti r-rekwiżiti. Chatbot tal-FAQ, sommarju, jew traduzzjoni jaqgħu taħt riskju minimu u jsejħu biss għal trasparenza bażika. Hekk kif ikun hemm konversazzjoni jew analiżi tas-sentimenti, timxi lejn riskju limitat, bl-obbligu li tgħarraf lill-utent li qed jinteraġixxi ma’ AI. Il-qabża hija għal għarrieda għal riskju għoli—punteġġ tal-kreditu, reklutaġġ, dijanjosi medika—fejn jiżdiedu l-valutazzjoni tal-konformità, il-ġestjoni tar-riskju, id-dokumentazzjoni tad-data tat-taħriġ, it-traċċabbiltà sħiħa, is-superviżjoni umana, u d-dimostrazzjoni tal-preċiżjoni. Ċerti użi, bħall-punteġġ soċjali jew il-manipulazzjoni subliminali, huma pprojbiti għalkollox.

# Ivvaluta l-livell ta' riskju tal-applikazzjoni tiegħek
RISK_LEVELS = {
    "minimal": {
        "examples": ["chatbot tal-FAQ", "sommarju tat-test", "traduzzjoni"],
        "obligations": ["Trasparenza bażika"]
    },
    "limited": {
        "examples": ["chatbot tas-servizz tal-klijenti", "analiżi tas-sentimenti"],
        "obligations": ["Għarraf lill-utent li qed jinteraġixxi ma' AI"]
    },
    "high": {
        "examples": ["punteġġ tal-kreditu", "reklutaġġ", "dijanjosi medika"],
        "obligations": [
            "Valutazzjoni tal-konformità",
            "Sistema ta' ġestjoni tar-riskju",
            "Data tat-taħriġ iddokumentata",
            "Reġistrazzjoni u traċċabbiltà sħiħa",
            "Superviżjoni umana obbligatorja",
            "Preċiżjoni u robustezza ddimostrati"
        ]
    },
    "unacceptable": {
        "examples": ["punteġġ soċjali", "manipulazzjoni subliminali"],
        "obligations": ["IPPROJBIT"]
    }
}

Poġġi l-proġett tiegħek b’mod onest f’din il-grilja qabel ma tikteb l-ewwel linja ta’ kodiċi: applikazzjoni kklassifikata bħala riskju għoli timponi restrizzjonijiet arkitettoniċi—reġistrazzjoni eżawrjenti, punt ta’ kontroll uman—li ma jistgħux jiġu mwaħħla wara l-fatt fuq sistema ddisinjata mingħajrhom.

Lista ta’ Verifika tal-Konformità

  • Traċċa tal-awditjar append-only b’timestamp
  • Hash tad-data personali fil-logs (qatt f’test ċar)
  • Moderazzjoni sistematika tal-inputs u l-outputs
  • Reġistru aġġornat tal-attivitajiet ta’ pproċessar tal-GDPR
  • Politika definita ta’ retenzjoni u arkivjar
  • Valutazzjoni tal-livell ta’ riskju tal-Att dwar l-AI mwettqa
  • Għarraf lill-utenti li qed jinteraġixxu ma’ AI
  • Superviżjoni umana għal deċiżjonijiet b’impatt

Punti Ewlenin

  • Traċċa tal-awditjar hija obbligatorja għall-konformità regolatorja
  • Irreġistra f’modalità append-only: qatt timmodifika reġistri eżistenti
  • Ħassar (hash) id-data personali kollha fil-logs tal-awditjar
  • L-Att Ewropew dwar l-AI jikklassifika l-applikazzjonijiet skont il-livell ta’ riskju
  • Implimenta moderazzjoni awtomatika U superviżjoni umana
  • Iddefinixxi politika ta’ retenzjoni u arkivja regolarment

Ittestja l-Għarfien Tiegħek

Tnejn u għoxrin lezzjoni tal-API: ivvalida l-mekkaniżmi li jżommu l-produzzjoni flimkien.

1. Għaliex timmigra lejn l-API tar-Risposti minflok tibqa' fuq Chat Completions?

Tweġiba: Hija l-API moderna ta’ OpenAI: ġestjoni integrata tal-istat tal-konversazzjoni, għodod nattivi, u evoluzzjoni ffukata fuqha—Chat Completions tibqa’ appoġġjata iżda antika.

2. Kif tagħżel bejn Sol, Terra, u Luna fuq in-naħa tal-API?

Tweġiba: gpt-5.6-sol għal kompiti ta’ ħtieġa, terra għal bilanċ kost/kwalità, luna għal volum ekonomiku—u l-livell tar-raġunament (none→max) imbagħad jiġi aġġustat għal kull talba.

3. X' jiggarantixxi l-Output Strutturat?

Tweġiba: Output li jikkonforma mal-iskema JSON ipprovduta—oqsma, tipi, struttura—sfruttabbli minn programm mingħajr parsing difensiv jew tiswija.

4. X'għandek tagħmel quddiem żball 429?

Tweġiba: Irrispetta l-limiti tar-rata: erġa’ pprova b’backoff esponenzjali (u jitter), illimita t-tentattivi, u ppjana għal circuit breaker—qatt loop ta’ retry immedjat.

5. Semmi żewġ protezzjonijiet indispensabbli fuq in-naħa tas-sigurtà tal-applikazzjoni.

Tweġiba: Moderazzjoni tal-kontenut li jidħol/u joħroġ permezz tal-API ddedikata, u difiża kontra l-injezzjoni tal-prompt: iżola l-istruzzjonijiet mid-data, ivvalida l-outputs, illimita l-kapaċitajiet esposti.

Produzzjoni, sigurtà, konformità: l-aħħar tliet blokok tal-kors jagħmlu d-differenza bejn prototip u servizz—żommhom bħala lista ta’ verifika.