Zhoda s predpismi a auditná stopa
Na tejto strane
Zhoda s predpismi a auditná stopa
Pre aplikácie umelej inteligencie v prevádzke je sledovateľnosť nevyhnutná. Úplná auditná stopa ťa ochráni počas inšpekcie, sporu alebo incidentu. Táto lekcia ti ukáže, ako implementovať robustný auditný systém, čím uzatvoríme kurz spojením všetkého, čo si doteraz vybudoval – logovanie, moderovanie a ochranu údajov – do jediného obhájiteľného rámca.
Prečo auditná stopa?
Štyri odlišné potreby sa zbiehajú v tej istej infraštruktúre. Po prvé, regulačná zhoda: GDPR, európsky akt o umelej inteligencii (AI Act) a odvetvové štandardy si vyžadujú, aby si preukázal, čo tvoj systém robí, a demonštrácia bez záznamov je bezcenná. Po druhé, sledovateľnosť v pravom zmysle slova – vedieť, kto čo urobil, kedy, s akým výsledkom, aj o šesť mesiacov neskôr. Ladenie chýb z toho profituje denne, pretože pochopenie neočakávaného správania modelu si vyžaduje obnovenie presných podmienok volania. Nakoniec, zodpovednosť: dokumentovanie rozhodnutí prijatých AI je to, čo ti umožní, keď nastane čas, ukázať, že sporné odporúčanie vychádzalo z kontrolovaného procesu.
Štruktúra auditného záznamu
Nižšie uvedená dataclass je rovnako zmluvou ako aj dátovou štruktúrou. Zoskupuje identifikátory, kontext aplikácie, požiadavku, odpoveď, verdikt moderovania a technické metadáta. Dve voľby si zaslúžia tvoju pozornosť. Identifikátor používateľa sa objavuje iba v hashovanej forme, nikdy nie v plain texte. A prompt sa neukladá: uchováva sa iba jeho hash a dĺžka. To ti zachováva schopnosť dokázať, že dva hovory sa týkali rovnakého obsahu, bez toho, aby si vôbec vytvoril archív toho, čo tvoji používatelia napísali.
from dataclasses import dataclass, field, asdict
from datetime import datetime
from typing import Optional
import json
import uuid
import hashlib
@dataclass
class AuditRecord:
"""Auditný záznam pre volanie API."""
# Identifikátory
audit_id: str = field(default_factory=lambda: str(uuid.uuid4()))
timestamp: str = field(
default_factory=lambda: datetime.now().isoformat()
)
# Kontext
user_id_hash: str = "" # Nikdy nie plain ID
session_id: str = ""
application: str = ""
# Požiadavka (žiadne citlivé údaje)
model: str = ""
prompt_hash: str = "" # Hash promptu, nie samotný prompt
prompt_length: int = 0
# Odpoveď
response_id: str = ""
output_length: int = 0
input_tokens: int = 0
output_tokens: int = 0
# Moderovanie
input_flagged: bool = False
output_flagged: bool = False
# Metadáta
duration_ms: int = 0
status: str = "success"
error: Optional[str] = None
def to_json(self) -> str:
return json.dumps(asdict(self), ensure_ascii=False)
Kompletný auditný systém
Klient, ktorý využíva túto štruktúru, reťazí moderovanie vstupu, volanie API, moderovanie výstupu a v každom prípade zapisuje. Dôležité slovo je len pripájanie (append-only): súbor JSONL sa otvára v režime pripájania, nikdy sa neprepisuje, čo je podmienkou, aby mal záznam dôkaznú hodnotu. Všimni si cestu označeného záznamu – záznam sa uloží predtým, ako sa vyvolá výnimka, so stavom blocked_input. Blokovanie teda zanechá stopu rovnako ako úspech a záverečný blok except garantuje, že žiadna chyba, nech už má akýkoľvek pôvod, neunikne pozornosti.
import time
from openai import OpenAI
class AuditedClient:
"""Klient OpenAI s integrovanou auditnou stopou."""
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:
"""Skosený hash SHA-256 na účely auditu."""
return hashlib.sha256(text.encode()).hexdigest()[:16]
def _save_audit(self, record: AuditRecord):
"""Uloží auditný záznam (len pripájanie)."""
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:
"""Volanie API s automatickým auditom."""
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:
# Moderovanie vstupu
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("Nevhodný obsah vstupu")
# Volanie API
response = self.client.responses.create(
model=model,
input=input,
**kwargs
)
# Moderovanie výstupu
mod_out = self.client.moderations.create(
model="omni-moderation-latest",
input=response.output_text
)
record.output_flagged = mod_out.results[0].flagged
# Vyplnenie metrík
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
# Použitie
audited = AuditedClient(application="support-chatbot")
response = audited.create(
user_id="[email protected]",
session_id="sess-abc123",
model="gpt-5.6-terra",
input="Ako môžem vrátiť produkt?"
)
print(response.output_text)
V tomto príklade sa e-mailová adresa odovzdaná ako user_id nikdy nedostane do súboru: hashuje sa hneď, ako sa zostaví záznam. Súbor JSONL funguje dobre na začiatok a pre jednu inštanciu; akonáhle viaceré procesy píšu paralelne, nasmeruj tento tok do databázy alebo zberača logov.
Dopyty do auditu
Log, ktorý nemôžeš dopytovať, slúži len na zapratanie miesta na disku. Čítanie formátu JSONL riadok po riadku robí využitie triviálnym a nižšie uvedený report sumarizuje pokryté obdobie, rozdelenie medzi úspechy, chyby a blokovania, spotrebu tokenov a priemernú latenciu. Počet jedinečných používateľov sa spolieha na hashe, čo mimochodom dokazuje, že pseudonymizovaný log zostáva dokonale analyzovateľný.
import json
def read_audit(file: str = "audit.jsonl") -> list[dict]:
"""Prečíta všetky auditné záznamy."""
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:
"""Generuje auditný report."""
records = read_audit(file)
if not records:
return {"message": "Žiadne záznamy"}
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))
Retencia a archivácia
Uchovávanie údajov na neurčito je v rozpore so zásadou obmedzenia uchovávania; príliš skoré vymazanie ťa pripraví o dôkaz, ktorý môžeš potrebovať. Rotácia rieši toto dilemu: po uplynutí tebou stanovenej doby – tu deväťdesiat dní – sa záznamy presunú z aktívneho súboru do datovaného archívu, zatiaľ čo aktuálny log sa prepíše iba s tými najnovšími. Naplánuj túto funkciu ako periodickú úlohu a zosúlaď retention_days s politikou schválenou tvojím právnym poradcom, nie s hodnotou vybranou náhodne.
from datetime import datetime, timedelta
import shutil
import os
def archive_audit(file: str = "audit.jsonl",
retention_days: int = 90):
"""Archivuje a vymazáva staré záznamy."""
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:
# Archivácia starých
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")
# Prepísanie hlavného súboru najnovšími
with open(file, "w", encoding="utf-8") as f:
for record in recent:
f.write(json.dumps(record, ensure_ascii=False) + "\n")
print(f"Archivovaných {len(archives)} záznamov do {archive_name}")
print(f"Ponechaných {len(recent)} najnovších záznamov")
Európsky akt o umelej inteligencii: Čo sa mení
Európsky akt o umelej inteligencii (AI Act) ukladá povinnosti na základe úrovne rizika tvojej aplikácie. Logika je graduovaná: čím viac tvoj systém váži na životoch ľudí, tým prísnejšie sú požiadavky. FAQ chatbot, zhrnutie alebo preklad spadajú pod minimálne riziko a vyžadujú si iba základnú transparentnosť. Akonáhle ide o konverzáciu alebo analýzu sentimentu, presúvaš sa do obmedzeného rizika s povinnosťou informovať používateľa, že interaguje s AI. Skok je prudký pri vysokom riziku – credit scoring, nábor, lekárska diagnostika – kde sa pridáva posúdenie zhody, riadenie rizík, dokumentácia trénovacích dát, úplná sledovateľnosť, ľudský dohľad a preukázanie presnosti. Určité použitia, ako je sociálne hodnotenie alebo subliminálna manipulácia, sú čisto zakázané.
# Posúď úroveň rizika svojej aplikácie
RISK_LEVELS = {
"minimal": {
"examples": ["FAQ chatbot", "textové zhrnutie", "preklad"],
"obligations": ["Základná transparentnosť"]
},
"limited": {
"examples": ["chatbot zákazníckej podpory", "analýza sentimentu"],
"obligations": ["Informovať používateľa, že interaguje s AI"]
},
"high": {
"examples": ["credit scoring", "nábor zamestnancov", "lekárska diagnostika"],
"obligations": [
"Posúdenie zhody",
"Systém riadenia rizík",
"Dokumentované trénovacie dáta",
"Logovanie a úplná sledovateľnosť",
"Povinný ľudský dohľad",
"Preukázaná presnosť a robustnosť"
]
},
"unacceptable": {
"examples": ["sociálne hodnotenie", "subliminálna manipulácia"],
"obligations": ["ZAKÁZANÉ"]
}
}
Úprimne situuj svoj projekt do tejto mriežky ešte pred napísaním prvého riadku kódu: aplikácia klasifikovaná ako vysoko riziková ukladá architektonické obmedzenia – vyčerpávajúce logovanie, bod ľudskej kontroly – ktoré nemožno dodatočne naštepiť systému navrhnutému bez nich.
Kontrolný zoznam zhody
- Auditná stopa len na pripájanie s časovou pečiatkou
- Hash osobných údajov v logoch (nikdy nie v plain texte)
- Systematické moderovanie vstupov a výstupov
- Aktualizovaný záznam o činnostiach spracúvania podľa GDPR
- Definovaná politika retencie a archivácie
- Vykonané posúdenie úrovne rizika podľa AI Act
- Informovanie používateľov, že interagujú s AI
- Ľudský dohľad pri rozhodnutiach s dopadom
Kľúčové poznatky
- Auditná stopa je povinná pre regulačnú zhodu
- Loguj v režime len na pripájanie: nikdy neupravuj existujúce záznamy
- Hashuj všetky osobné údaje v auditných logoch
- Európsky akt o umelej inteligencii klasifikuje aplikácie podľa úrovne rizika
- Implementuj automatické moderovanie AJ ľudský dohľad
- Definuj politiku retencie a pravidelne archivuj
Otestuj si svoje vedomosti
Dvadsaťdva lekcií o API: over si mechanizmy, ktoré držia prevádzku pohromade.
1. Prečo migrovať na Responses API namiesto zotrvania na Chat Completions?
Odpoveď: Je to moderné API od OpenAI: integrovaná správa stavu konverzácie, natívne nástroje a evolúcia zameraná naň – Chat Completions zostáva podporované, ale je legacy.
2. Ako si vybrať medzi Sol, Terra a Luna na strane API?
Odpoveď: gpt-5.6-sol pre náročné úlohy, terra pre rovnováhu cena/kvalita, luna pre ekonomický objem – a úroveň logického uvažovania (none→max) sa následne upravuje podľa požiadavky.
3. Čo garantuje Štruktúrovaný výstup (Structured Output)?
Odpoveď: Výstup zodpovedajúci poskytnutej schéme JSON – polia, typy, štruktúra – využiteľný programom bez obranného parsingu alebo opráv.
4. Čo robiť tvárou v tvár chybe 429?
Odpoveď: Rešpektuj limity rýchlosti: opakuj s exponenciálnym oneskorením (a jitterom), obmedz počet pokusov a plánuj istič (circuit breaker) – nikdy nie okamžitá slučka opakovania.
5. Vymenuj dve nevyhnutné ochrany na strane bezpečnosti aplikácie.
Odpoveď: Moderovanie prichádzajúceho/odchádzajúceho obsahu cez vyhradené API a obrana proti vstrekovaniu promptov (prompt injection): izoluj inštrukcie od dát, validuj výstupy, obmedz exponované kapacity.
Prevádzka, bezpečnosť, zhoda s predpismi: posledné tri bloky kurzu robia rozdiel medzi prototypom a službou – maj ich ako kontrolný zoznam.