Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Dodržování předpisů a auditní stopa

Lekce 22 z 22 Aktualizováno 29. července 2026 Vývojář
Na této stránce
  1. Dodržování předpisů a auditní stopa
  2. Proč auditní stopa?
  3. Struktura auditního záznamu
  4. Kompletní auditní systém
  5. Dotazy na audit
  6. Retence a archivace
  7. Evropský zákon o umělé inteligenci: Co se mění
  8. Kontrolní seznam souladu s předpisy
  9. Klíčové poznatky
  10. Otestuj své znalosti

Dodržování předpisů a auditní stopa

U aplikací umělé inteligence v produkčním prostředí je sledovatelnost nezbytná. Úplná auditní stopa tě ochrání během inspekce, sporu nebo incidentu. Tato lekce ti ukáže, jak implementovat robustní auditní systém, čímž uzavře celý kurz spojením všeho, co jsi doposud vybudoval – logování, moderaci a ochranu dat – do jediného obhajitelného rámce.

Proč auditní stopa?

Čtyři odlišné potřeby se sbíhají na stejné infrastruktuře. Zaprvé, soulad s předpisy: GDPR, evropský zákon o umělé inteligenci (AI Act) a odvětvové normy vyžadují, abys prokázal, co tvůj systém dělá, a demonstrace bez logů je k ničemu. Zadruhé, sledovatelnost v pravém slova smyslu – vědět, kdo co udělal, kdy, s jakým výsledkem, dokonce i o šest měsíců později. Ladění chyb z toho těží denně, protože pochopení neočekávaného chování modelu vyžaduje obnovení přesných podmínek volání. Nakonec odpovědnost: dokumentace rozhodnutí přijatých umělou inteligencí je tím, co ti umožní, až nastane čas, prokázat, že zpochybněné doporučení vycházelo z řízeného procesu.

Struktura auditního záznamu

Níže uvedená dataclass je stejně tak smlouvou jako datovou strukturou. Sdružuje identifikátory, kontext aplikace, požadavek, odpověď, verdikt moderace a technická metadata. Dvě volby si zaslouží tvou pozornost. Identifikátor uživatele se objevuje pouze v hashované podobě, nikdy v prostém textu. A prompt se neukládá: ukládá se pouze jeho hash a délka. To ti zachovává schopnost prokázat, že dvě volání se týkala stejného obsahu, aniž bys kdy vytvořil archiv toho, co tvoji uživatelé napsali.

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 pro volání 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 ne plain ID
    session_id: str = ""
    application: str = ""

    # Požadavek (žádná citlivá data)
    model: str = ""
    prompt_hash: str = ""  # Hash promptu, ne samotný prompt
    prompt_length: int = 0

    # Odpověď
    response_id: str = ""
    output_length: int = 0
    input_tokens: int = 0
    output_tokens: int = 0

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

Kompletní auditní systém

Klient, který využívá tuto strukturu, řetězí moderaci vstupu, volání API, moderaci výstupu a zapisuje v každém případě. Důležité slovo je pouze pro připojování (append-only): soubor JSONL je otevřen v režimu připojování, nikdy nepřepisován, což je podmínkou, aby měl log důkazní hodnotu. Všimni si cesty označeného záznamu – záznam je uložen před vyvoláním výjimky se stavem blocked_input. Blokování tedy zanechá stopu stejně jako úspěch a závěrečný blok except zaručuje, že žádná chyba, ať už má jakýkoli původ, neunikne pozornosti.

import time
from openai import OpenAI

class AuditedClient:
    """Klient OpenAI s integrovanou auditní 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:
        """Zkrácený hash SHA-256 pro audit."""
        return hashlib.sha256(text.encode()).hexdigest()[:16]

    def _save_audit(self, record: AuditRecord):
        """Uloží auditní záznam (pouze pro připojování)."""
        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:
        """Volání API s automatickým auditováním."""

        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:
            # Moderace 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("Inappropriate input content")

            # Volání API
            response = self.client.responses.create(
                model=model,
                input=input,
                **kwargs
            )

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

            # Naplnění metrik
            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žití
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 tomto příkladu se e-mailová adresa předaná jako user_id nikdy nedostane do souboru: je hashována hned při konstrukci záznamu. Soubor JSONL funguje dobře pro začátek a pro jednu instanci; jakmile však více procesů zapisuje paralelně, nasměruj tento tok do databáze nebo sběrače logů.

Dotazy na audit

Log, který nemůžeš dotazovat, slouží jen k zaplňování místa na disku. Čtení formátu JSONL řádek po řádku činí využití triviálním a níže uvedený přehled shrnuje pokryté období, rozdělení mezi úspěchy, chyby a blokování, spotřebu tokenů a průměrnou latenci. Počet jedinečných uživatelů spoléhá na hashe, což mimochodem dokazuje, že pseudonymizovaný log zůstává plně analyzovatelný.

import json

def read_audit(file: str = "audit.jsonl") -> list[dict]:
    """Přečte všechny 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í přehled."""
    records = read_audit(file)

    if not records:
        return {"message": "Žádné 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))

Retence a archivace

Uchovávání dat na neurčito je v rozporu se zásadou omezení uložení; příliš brzké smazání tě připraví o důkaz, který můžeš potřebovat. Rotace řeší toto dilema: po uplynutí doby, kterou stanovíš – zde devadesát dní – záznamy opustí aktivní soubor a přejdou do datovaného archivu, zatímco aktuální log se přepíše pouze s těmi nedávnými. Naplánuj tuto funkci jako periodický úkol a slad retention_days s politikou schválenou tvým právním poradcem, nikoli s hodnotou vybranou náhodně.

from datetime import datetime, timedelta
import shutil
import os

def archive_audit(file: str = "audit.jsonl",
                  retention_days: int = 90):
    """Archivuje a maže 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:
        # Archivace 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")

        # Přepsání hlavního souboru nedávný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"Archivováno {len(archives)} záznamů do {archive_name}")
        print(f"Ponecháno {len(recent)} nedávných záznamů")

Evropský zákon o umělé inteligenci: Co se mění

Evropský zákon o umělé inteligenci (AI Act) ukládá povinnosti na základě úrovně rizika tvé aplikace. Logika je stupňovitá: čím více tvůj systém váží na životech lidí, tím přísnější jsou požadavky. Chatbot s FAQ, shrnutí nebo překlad spadají pod minimální riziko a vyžadují pouze základní transparentnost. Jakmile jde o konverzaci nebo analýzu sentimentu, přesouváš se do omezeného rizika s povinností informovat uživatele, že interaguje s umělou inteligencí. Skok je prudký u vysokého rizika – kreditní scoring, nábor, lékařská diagnóza – kde se přidává posouzení shody, řízení rizik, dokumentace trénovacích dat, úplná sledovatelnost, lidský dohled a prokázání přesnosti. Určitá použití, jako je sociální scoring nebo subliminální manipulace, jsou čistě zakázána.

# Posuď úroveň rizika své aplikace
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"]
    }
}

Upřímně umísti svůj projekt do této mřížky ještě před napsáním prvního řádku kódu: aplikace klasifikovaná jako vysoce riziková ukládá architektonická omezení – vyčerpávající logování, bod lidské kontroly – která nelze dodatečně přilepit na systém navržený bez nich.

Kontrolní seznam souladu s předpisy

  • Auditní stopa pouze pro připojování s časovým razítkem
  • Hash osobních údajů v logách (nikdy v prostém textu)
  • Systematická moderace vstupů a výstupů
  • Aktualizovaný záznam o činnostech zpracování podle GDPR
  • Definovaná politika retence a archivace
  • Provedeno posouzení úrovně rizika podle AI Act
  • Informování uživatelů, že interagují s umělou inteligencí
  • Lidský dohled pro rozhodnutí s dopadem

Klíčové poznatky

  • Auditní stopa je povinná pro soulad s předpisy
  • Loguj v režimu pouze pro připojování: nikdy neměň existující záznamy
  • Hashuj všechna osobní data v auditních logách
  • Evropský zákon o umělé inteligenci klasifikuje aplikace podle úrovně rizika
  • Implementuj automatickou moderaci A lidský dohled
  • Definuj politiku retence a pravidelně archivuj

Otestuj své znalosti

Dvacet dvě lekcí API: ověř mechanismy, které drží produkci pohromadě.

1. Proč migrovat na Responses API místo setrvání na Chat Completions?

Odpověď: Je to moderní API od OpenAI: integrovaná správa stavu konverzace, nativní nástroje a vývoj zaměřený na něj – Chat Completions zůstává podporované, ale zastaralé.

2. Jak vybrat mezi Sol, Terra a Luna na straně API?

Odpověď: gpt-5.6-sol pro náročné úlohy, terra pro rovnováhu cena/kvalita, luna pro ekonomický objem – a úroveň uvažování (none→max) se poté upravuje na žádost.

3. Co garantuje Strukturovaný výstup?

Odpověď: Výstup odpovídající poskytnutému schématu JSON – pole, typy, struktura – využitelný programem bez obranného parsování nebo oprav.

4. Co dělat tváří v tvář chybě 429?

Odpověď: Respektuj limity sazeb: opakuj s exponenciálním backoffem (a jitterem), omez počet pokusů a plánuj jistič – nikdy ne okamžitou smyčku opakování.

5. Jmenuj dvě nepostradatelné ochrany na straně bezpečnosti aplikace.

Odpověď: Moderace příchozího/odchozího obsahu prostřednictvím vyhrazeného API a obrana proti injektáži promptů: izoluj instrukce od dat, validuj výstupy, omez exponované schopnosti.

Produkce, bezpečnost, soulad s předpisy: poslední tři bloky kurzu dělají rozdíl mezi prototypem a službou – měj je jako kontrolní seznam.