Overholdelse og revisionslog
På denne side
Overholdelse og revisionslog
For AI-applikationer i produktion er sporbarhed afgørende. En komplet revisionslog beskytter dig under en inspektion, en tvist eller en hændelse. Denne lektion viser dig, hvordan du implementerer et robust revisionssystem, der afrunder kurset ved at samle alt, hvad du har bygget hidtil – logning, moderering og databeskyttelse – i én enkelt, forsvarlig ramme.
Hvorfor en revisionslog?
Fire forskellige behov mødes i den samme infrastruktur. For det første regulatorisk overholdelse: GDPR, den europæiske AI-forordning (AI Act) og branchestandarder kræver alle, at du kan demonstrere, hvad dit system gør, og en demonstration uden logge er værdiløs. For det andet sporbarhed i streng forstand – at vide hvem der gjorde hvad, hvornår, med hvilket resultat, selv seks måneder senere. Fejlfinding drager dagligt fordel af dette, da forståelse af uventet modeladfærd kræver, at du kan genskabe de nøjagtige forhold for kaldet. Endelig ansvarlighed: Dokumentation af beslutninger truffet af AI’en er det, der vil gøre det muligt for dig, når tiden inde, at vise, at en omdiskuteret anbefaling hvilede på en kontrolleret proces.
Struktur for en revisionspost
dataclass-en nedenfor er lige så meget en kontrakt som en datastruktur. Den grupperer identifikatorer, applikationskontekst, anmodningen, svaret, modereringskendelsen og tekniske metadata. To valg fortjener din opmærksomhed. Brugeridentifikatoren forekommer kun i hashet form, aldrig i klar tekst. Og prompten gemmes ikke: kun dens hash og længde gemmes. Dette bevarer din evne til at bevise, at to kald vedrørte det samme indhold, uden nogensinde at skabe et arkiv over, hvad dine brugere har skrevet.
from dataclasses import dataclass, field, asdict
from datetime import datetime
from typing import Optional
import json
import uuid
import hashlib
@dataclass
class AuditRecord:
"""Audit record for an API call."""
# Identifiers
audit_id: str = field(default_factory=lambda: str(uuid.uuid4()))
timestamp: str = field(
default_factory=lambda: datetime.now().isoformat()
)
# Context
user_id_hash: str = "" # Never the plain ID
session_id: str = ""
application: str = ""
# Request (no sensitive data)
model: str = ""
prompt_hash: str = "" # Hash of the prompt, not the prompt itself
prompt_length: int = 0
# Response
response_id: str = ""
output_length: int = 0
input_tokens: int = 0
output_tokens: int = 0
# Moderation
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)
Komplet revisionssystem
Klienten, der udnytter denne struktur, kæder input-moderering, API-kaldet, output-moderering og skrivning sammen i alle tilfælde. Det vigtige ord er kun-tilføjelse (append-only): JSONL-filen åbnes i tilføjelsestilstand og overskrives aldrig, hvilket er betingelsen for, at en log har bevisværdi. Bemærk stien for en flagget post – posten gemmes før undtagelsen udløses, med statussen blocked_input. En blokering efterlader derfor et spor ligesom en succes, og den sidste except-blok garanterer, at ingen fejl, uanset oprindelse, slipper under radaren.
import time
from openai import OpenAI
class AuditedClient:
"""OpenAI client with integrated audit trail."""
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:
"""Truncated SHA-256 hash for auditing."""
return hashlib.sha256(text.encode()).hexdigest()[:16]
def _save_audit(self, record: AuditRecord):
"""Saves an audit record (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:
"""API call with automatic auditing."""
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:
# Input moderation
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")
# API call
response = self.client.responses.create(
model=model,
input=input,
**kwargs
)
# Output moderation
mod_out = self.client.moderations.create(
model="omni-moderation-latest",
input=response.output_text
)
record.output_flagged = mod_out.results[0].flagged
# Fill metrics
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
# Usage
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)
I dette eksempel når e-mail-adressen, der sendes som user_id, aldrig filen: den hashes, så snart posten konstrueres. En JSONL-fil fungerer fint til at komme i gang og til en enkelt instans; så snart flere processer skriver parallelt, skal du dirigere denne strøm til en database eller en logsamler.
Revisionsforespørgsler
En log, du ikke kan spørge til, tjener kun til at optage diskplads. Linje-for-linje-læsning af JSONL-formatet gør udnyttelse triviel, og rapporten nedenfor opsummerer den dækkede periode, fordelingen mellem succeser, fejl og blokeringer, tokenforbrug og gennemsnitlig ventetid. Optællingen af unikke brugere baserer sig på hashes, hvilket beviser tilfældigt, at en pseudonymiseret log forbliver fuldt ud analyserbar.
import json
def read_audit(file: str = "audit.jsonl") -> list[dict]:
"""Reads all audit records."""
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:
"""Generates an audit report."""
records = read_audit(file)
if not records:
return {"message": "No records"}
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))
Opbevaring og arkivering
At beholde data på ubestemt tid strider mod princippet om begrænsning af opbevaring; at slette for tidligt fratager dig det bevis, du måske får brug for. Rotation løser dette dilemma: ud over en varighed, du fastsætter – her halvfems dage – flyttes poster fra den aktive fil til et dateret arkiv, mens den aktuelle log omskrives med kun de seneste. Planlæg denne funktion som en periodisk opgave og tilpas retention_days til den politik, der er valideret af din juridiske rådgiver, ikke en værdi valgt tilfældigt.
from datetime import datetime, timedelta
import shutil
import os
def archive_audit(file: str = "audit.jsonl",
retention_days: int = 90):
"""Archives and purges old records."""
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:
# Archive old ones
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")
# Rewrite main file with recent ones
with open(file, "w", encoding="utf-8") as f:
for record in recent:
f.write(json.dumps(record, ensure_ascii=False) + "\n")
print(f"Archived {len(archives)} records to {archive_name}")
print(f"Kept {len(recent)} recent records")
Den europæiske AI-forordning: Hvad ændrer sig
Den europæiske AI-forordning (AI Act) pålægger forpligtelser baseret på risikoniveauet for din applikation. Logikken er gradueret: jo mere dit system vejer ind på menneskers liv, desto strengere er kravene. En FAQ-chatbot, et resumé eller en oversættelse falder under minimal risiko og kræver kun grundlæggende gennemsigtighed. Så snart der er samtale eller sentimentanalyse, rykker du til begrænset risiko, med forpligtelsen til at informere brugeren om, at de interagerer med en AI. Springet er brat for høj risiko – kreditvurdering, rekruttering, medicinsk diagnose – hvor overensstemmelsesvurdering, risikostyring, dokumentation af træningsdata, komplet sporbarhed, menneskelig tilsyn og demonstration af nøjagtighed tilføjes. Visse anvendelser, såsom social scoring eller subliminal manipulation, er rent forbudt.
# Assess the risk level of your application
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"]
}
}
Placér ærligt dit projekt i dette gitter, før du skriver den første linje kode: en applikation klassificeret som høj risiko pålægger arkitektoniske begrænsninger – udtømmende logning, menneskeligt kontrolpunkt – som ikke kan påføres efterfølgende på et system designet uden dem.
Tjekliste for overholdelse
- Revisionslog kun-tilføjelse med tidsstempel
- Hash af personoplysninger i logge (aldrig i klar tekst)
- Systematisk moderering af input og output
- Opdateret GDPR-register over behandlingsaktiviteter
- Defineret politik for opbevaring og arkivering
- Vurdering af risikoniveau ifølge AI-forordningen udført
- Informér brugere om, at de interagerer med en AI
- Menneskelig tilsyn ved beslutninger med stor indvirkning
Vigtige pointer
- En revisionslog er obligatorisk for regulatorisk overholdelse
- Log i kun-tilføjelse-tilstand: modificér aldrig eksisterende poster
- Hash alle personoplysninger i revisionslogge
- Den europæiske AI-forordning klassificerer applikationer efter risikoniveau
- Implementér automatisk moderering OG menneskelig tilsyn
- Definer en opbevaringspolitik og arkivér regelmæssigt
Test din viden
Toogtyve API-lektioner: valider de mekanismer, der holder produktionen sammen.
1. Hvorfor migrere til Responses API i stedet for at blive på Chat Completions?
Svar: Det er OpenAIs moderne API: integreret styring af samtalestatus, native værktøjer og udvikling fokuseret herpå – Chat Completions forbliver understøttet, men er forældet.
2. Hvordan vælger du mellem Sol, Terra og Luna på API-siden?
Svar: gpt-5.6-sol til krævende opgaver, terra til balance mellem omkostninger og kvalitet, luna til økonomisk volumen – og resonansniveauet (none→max) justeres derefter pr. anmodning.
3. Hvad garanterer Structured Output?
Svar: Output, der overholder det angivne JSON-skema – felter, typer, struktur – udnytbart af et program uden defensiv parsing eller reparation.
4. Hvad gør du i tilfælde af en 429-fejl?
Svar: Overhold hastighedsbegrænsninger: genprøv med eksponentiel backoff (og jitter), sæt loft over forsøg, og planlæg for en circuit breaker – aldrig en øjeblikkelig genprøvningsløkke.
5. Nævn to uundværlige beskyttelser på applikationssikkerhedssiden.
Svar: Moderering af indgående/udgående indhold via det dedikerede API og forsvar mod prompt-injection: isolér instruktioner fra data, valider output, begræns eksponerede funktioner.
Produktion, sikkerhed, overholdelse: de sidste tre blokke i kurset gør forskellen mellem en prototype og en tjeneste – behold dem som en tjekliste.