Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Skladnost in revizijska sled

Lekcija 22 od 22 Posodobljeno 29. julij 2026 Razvijalec
Na tej strani
  1. Skladnost in revizijska sled
  2. Zakaj revizijska sled?
  3. Struktura revizijskega zapisa
  4. Celoten revizijski sistem
  5. Poizvedbe po reviziji
  6. Hranjenje in arhiviranje
  7. Evropski akt o umetni inteligenci: Kaj se spremeni
  8. Kontrolni seznam skladnosti
  9. Ključne ugotovitve
  10. Preveri svoje znanje

Skladnost in revizijska sled

Pri aplikacijah z umetno inteligenco v proizvodnem okolju je sledljivost nujna. Popolna revizijska sled te zaščiti med inšpekcijo, sporom ali incidentom. Ta lekcija ti pokaže, kako implementirati robusten revizijski sistem, s čimer zaključimo tečaj z združitvijo vsega, kar si doslej zgradil – beleženja dogodkov, moderiranja in zaščite podatkov – v en sam, zagovornljiv okvir.

Zakaj revizijska sled?

Štiri različne potrebe se stekajo v isto infrastrukturo. Prvič, skladnost z predpisi: splošna uredba o varstvu podatkov (GDPR), evropski akt o umetni inteligenci in industrijski standardi od tebe zahtevajo, da dokažeš, kaj tvoj sistem počne, demonstracija brez dnevnikov pa je brez vrednosti. Drugič, sledljivost v strogem pomenu – vedeti, kdo je kaj storil, kdaj, z kakšnim rezultatom, tudi šest mesecev kasneje. Odpravljanje napak ima od tega vsakodnevne koristi, saj razumevanje nepričakovanega obnašanja modela zahteva obnovitev točnih pogojev klica. Nazadnje, odgovornost: dokumentiranje odločitev, ki jih sprejme umetna inteligenca, ti bo omogočilo, da ob pravem času dokažeš, da je sporna rekomandacija temeljila na nadzorovanem procesu.

Struktura revizijskega zapisa

Spodnji razred dataclass je enako pogodba kot podatkovna struktura. Združuje identifikatorje, kontekst aplikacije, zahtevo, odgovor, sodbo moderiranja in tehnične metapodatke. Dve izbiri si zaslužita tvojo pozornost. Identifikator uporabnika se pojavi le v zgoščeni (hash) obliki, nikoli v čistem besedilu. Tudi poziv (prompt) ni shranjen: shranita se le njegova zgoščena vrednost in dolžina. To ohranja tvojo sposobnost dokazovanja, da sta se dva klica nanašala na isto vsebino, ne da bi kdaj ustvaril arhiv tega, kar so tvoji uporabniki napisali.

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

@dataclass
class AuditRecord:
    """Revizijski zapis za klic API."""
    # Identifikatorji
    audit_id: str = field(default_factory=lambda: str(uuid.uuid4()))
    timestamp: str = field(
        default_factory=lambda: datetime.now().isoformat()
    )

    # Kontekst
    user_id_hash: str = ""  # Nikoli čisti ID
    session_id: str = ""
    application: str = ""

    # Zahteva (brez občutljivih podatkov)
    model: str = ""
    prompt_hash: str = ""  # Hash poziva, ne sam poziv
    prompt_length: int = 0

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

    # Moderiranje
    input_flagged: bool = False
    output_flagged: bool = False

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

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

Celoten revizijski sistem

Odjemalec, ki izkorišča to strukturo, veriži moderiranje vhoda, klic API, moderiranje izhoda in v vsakem primeru zapisuje. Pomembna beseda je samo dodajanje (append-only): datoteka JSONL je odprta v načinu dodajanja, nikoli prepisana, kar je pogoj, da ima dnevnik dokazno vrednost. Opazi pot označenega vnosa – zapis se shrani preden se sproži izjema, s statusom blocked_input. Blokada torej pusti sled enako kot uspeh, končni blok except pa zagotavlja, da nobena napaka, ne glede na njen izvor, ne uide pozornosti.

import time
from openai import OpenAI

class AuditedClient:
    """Odjemalec OpenAI z integrirano revizijsko sledjo."""

    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:
        """Okrajšan hash SHA-256 za revizijo."""
        return hashlib.sha256(text.encode()).hexdigest()[:16]

    def _save_audit(self, record: AuditRecord):
        """Shrani revizijski zapis (samo dodajanje)."""
        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:
        """Klic API z avtomatskim beleženjem."""

        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:
            # Moderiranje vhoda
            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("Neustrezna vsebina vhoda")

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

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

            # Izpolni metrike
            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

# Uporaba
audited = AuditedClient(application="support-chatbot")

response = audited.create(
    user_id="[email protected]",
    session_id="sess-abc123",
    model="gpt-5.6-terra",
    input="How do I return a product?"
)
print(response.output_text)

V tem primeru e-poštni naslov, podan kot user_id, nikoli ne pride v datoteko: zgoščen je takoj, ko je zapis konstruiran. Datoteka JSONL dobro deluje za začetek in za enojni primerek; takoj ko več procesov piše vzporedno, preusmeri ta tok v bazo podatkov ali zbiralnik dnevnikov.

Poizvedbe po reviziji

Dnevnik, ki ga ne moreš poizvedovati, služi le zasedanju prostora na disku. Branje formatiranja JSONL vrstica za vrstico omogoča trivialno izkoriščanje, spodnje poročilo pa povzema zajeto obdobje, porazdelitev med uspehi, napakami in blokadami, porabo žetonov in povprečno zakasnitev. Štetje edinstvenih uporabnikov temelji na zgoščenih vrednostih, kar mimogrede dokazuje, da ostaja psevdonimiziran dnevnik popolnoma analizabilen.

import json

def read_audit(file: str = "audit.jsonl") -> list[dict]:
    """Prebere vse revizijske zapise."""
    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:
    """Ustvari revizijsko poročilo."""
    records = read_audit(file)

    if not records:
        return {"message": "Ni zapisov"}

    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))

Hranjenje in arhiviranje

Nedoločeno hranjenje podatkov je v nasprotju z načelom omejitve hrambe; prezgodnje brisanje te prikrajša za dokaz, ki ga morda potrebuješ. Rotacija reši to dilemo: po trajanju, ki ga določiš – tukaj devetdeset dni – zapisi zapustijo aktivno datoteko za datirani arhiv, medtem ko se trenutni dnevnik prepiše le z nedavnimi. To funkcijo načrtuj kot periodično nalogo in uskladi retention_days s politiko, ki jo je potrdil tvoj pravni svetovalec, ne z naključno izbrano vrednostjo.

from datetime import datetime, timedelta
import shutil
import os

def archive_audit(file: str = "audit.jsonl",
                  retention_days: int = 90):
    """Arhivira in počisti stare zapise."""
    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:
        # Arhiviraj stare
        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")

        # Prepiši glavno datoteko z nedavnimi
        with open(file, "w", encoding="utf-8") as f:
            for record in recent:
                f.write(json.dumps(record, ensure_ascii=False) + "\n")

        print(f"Arhiviranih {len(archives)} zapisov v {archive_name}")
        print(f"Obdržanih {len(recent)} nedavnih zapisov")

Evropski akt o umetni inteligenci: Kaj se spremeni

Evropski akt o umetni inteligenci (AI Act) nalaga obveznosti glede na raven tveganja tvoje aplikacije. Logika je stopnjevana: bolj ko tvoj sistem vpliva na življenja ljudi, strožje so zahteve. Klepetalni bot za pogosta vprašanja, povzetek ali prevod spada pod minimalno tveganje in zahteva le osnovno transparentnost. Takoj ko gre za pogovor ali analizo sentimenta, preideš na omejeno tveganje, z obveznostjo obvestiti uporabnika, da komunicira z umetno inteligenco. Skok je nenaden za visoko tveganje – bonitetno ocenjevanje, zaposlovanje, medicinska diagnoza – kjer se dodajo ocena skladnosti, upravljanje tveganj, dokumentacija učnih podatkov, popolna sledljivost, človeški nadzor in dokazovanje točnosti. Določene uporabe, kot so socialno ocenjevanje ali subliminalna manipulacija, so strogo prepovedane.

# Oceni raven tveganja svoje aplikacije
RISK_LEVELS = {
    "minimal": {
        "examples": ["FAQ chatbot", "text summary", "translation"],
        "obligations": ["Basic transparency"]
    },
    "limited": {
        "examples": ["customer service chatbot", "sentiment analysis"],
        "obligations": ["Inform the user they are interacting with an AI"]
    },
    "high": {
        "examples": ["credit scoring", "recruitment", "medical diagnosis"],
        "obligations": [
            "Conformity assessment",
            "Risk management system",
            "Documented training data",
            "Logging and complete traceability",
            "Mandatory human supervision",
            "Demonstrated accuracy and robustness"
        ]
    },
    "unacceptable": {
        "examples": ["social scoring", "subliminal manipulation"],
        "obligations": ["PROHIBITED"]
    }
}

Iskreno umesti svoj projekt v to mrežo preden napišeš prvo vrstico kode: aplikacija, razvrščena kot visoko tvegana, nalaga arhitekturne omejitve – izčrpno beleženje, točka človeškega nadzora – ki jih ni mogoče naknadno nalepiti na sistem, zasnovan brez njih.

Kontrolni seznam skladnosti

  • Revizijska sled samo z dodajanjem in časovnim žigom
  • Zgoščeni osebni podatki v dnevnikih (nikoli v čistem besedilu)
  • Sistematično moderiranje vhodov in izhodov
  • Posodobljen register dejavnosti obdelave v skladu z GDPR
  • Opredeljena politika hrambe in arhiviranja
  • Izvedena ocena ravni tveganja po aktu o umetni inteligenci
  • Obvestilo uporabnikom, da komunicirajo z umetno inteligenco
  • Človeški nadzor za odločitve z vplivom

Ključne ugotovitve

  • Revizijska sled je obvezna za skladnost s predpisi
  • Beleži v načinu samo dodajanja: nikoli ne spreminjaj obstoječih zapisov
  • Zgošči vse osebne podatke v revizijskih dnevnikih
  • Evropski akt o umetni inteligenci razvršča aplikacije po ravni tveganja
  • Implementiraj avtomatsko moderiranje IN človeški nadzor
  • Opredeli politiko hrambe in redno arhiviraj

Preveri svoje znanje

Dvaindvajset lekcij o API-ju: potrdi mehanizme, ki držijo proizvodno okolje skupaj.

1. Zakaj migrirati na Responses API namesto ostajanja na Chat Completions?

Odgovor: To je sodobni API OpenAI: integrirano upravljanje stanja pogovora, izvorna orodja in razvoj, osredotočen nanj – Chat Completions ostaja podprt, a zastarel.

2. Kako izbereš med Sol, Terra in Luna na strani API?

Odgovor: gpt-5.6-sol za zahtevne naloge, terra za ravnovesje med stroški in kakovostjo, luna za ekonomske volumne – raven razmišljanja (none→max) se nato prilagodi na zahtevo.

3. Kaj zagotavlja Structured Output?

Odgovor: Izhod, ki ustreza podani shemi JSON – polja, tipi, struktura – izkoristljiv s strani programa brez obrambnega razčlenjevanja ali popravil.

4. Kaj storiš ob napaki 429?

Odgovor: Spoštuj omejitve hitrosti: poskusi znova z eksponentnim zamikom (in jitterjem), omeji število poskusov in načrtuj odklopnik – nikoli ne uporabi takojšnje zanke ponavljanja.

5. Imenuj dve nepogrešljivi zaščiti na strani varnosti aplikacije.

Odgovor: Moderiranje dohodne/odhodne vsebine prek namenskega API in obramba pred vbrizgavanjem pozivov: izoliraj navodila od podatkov, validiraj izhode, omeji izpostavljene zmožnosti.

Proizvodnja, varnost, skladnost: zadnji trije bloki tečaja naredijo razliko med prototipom in storitvijo – obdrži jih kot kontrolni seznam.