Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Zhoda s predpismi a auditná stopa

Lekcia 22 z 22 Aktualizované 29. júla 2026 Vývojár
Na tejto strane
  1. Zhoda s predpismi a auditná stopa
  2. Prečo auditná stopa?
  3. Štruktúra auditného záznamu
  4. Kompletný auditný systém
  5. Dopyty do auditu
  6. Retencia a archivácia
  7. Európsky akt o umelej inteligencii: Čo sa mení
  8. Kontrolný zoznam zhody
  9. Kľúčové poznatky
  10. Otestuj si svoje vedomosti

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.