Vastavus ja auditeerimise jälg
Sellel lehel
Vastavus ja auditeerimise jälg
Tootmises olevate tehisintellekti rakenduste puhul on jälgitavus hädavajalik. Täielik auditeerimise jälg kaitseb sind inspektsiooni, vaidluse või intsidenti korral. See tund õpetab, kuidas rakendada töökindel auditeerimissüsteem, viies kursuse lõpule ja ühendades kõik senini loodu – logimine, modereerimine ja andmekaitse – üheks terviklikuks ja kaitstavaks raamistikuks.
Miks on vaja auditeerimise jälge?
Neli erinevat vajadust koondub sama taristu ümber. Esiteks regulatiivne vastavus: GDPR, Euroopa tehisintellekti määrus ja tööstusstandardid nõuavad kõik, et saaksid demonstreerida, mida sinu süsteem teeb, ning demonstratsioon ilma logideta on väärtusetu. Teiseks jälgitavus rangeimas tähenduses – teadmine, kes tegi mida, millal, millise tulemusega, isegi kuus kuud hiljem. Silumine saab sellest igapäevaselt kasu, sest ootamatu mudeli käitumise mõistmine eeldab päringu täpsete tingimuste taastamist. Lõpuks vastutus: tehisintellekti tehtud otsuste dokumenteerimine on see, mis võimaldab sul vajadusel näidata, et vaidlustatud soovitus põhines kontrollitud protsessil.
Auditeerimiskirje struktuur
Allpool olev dataclass on sama palju leping kui andmestruktuur. See koondab identifikaatorid, rakenduse konteksti, päringu, vastuse, modereerimise otsuse ja tehnilised metaandmed. Kaks valikut väärivad tähelepanu. Kasutaja identifikaator ilmub ainult räsitud kujul, mitte kunagi lahtises tekstis. Ja vihjet (prompt) ei salvestata: salvestatakse ainult selle räsi ja pikkus. See säilitab sinu võime tõestada, et kaks päringut puudutasid sama sisu, loomata samal ajal arhiivi sellest, mida sinu kasutajad kirjutasid.
from dataclasses import dataclass, field, asdict
from datetime import datetime
from typing import Optional
import json
import uuid
import hashlib
@dataclass
class AuditRecord:
"""API päringu auditeerimiskirje."""
# Identifikaatorid
audit_id: str = field(default_factory=lambda: str(uuid.uuid4()))
timestamp: str = field(
default_factory=lambda: datetime.now().isoformat()
)
# Kontekst
user_id_hash: str = "" # Mitte kunagi lahtine ID
session_id: str = ""
application: str = ""
# Päring (ei sisalda tundlikke andmeid)
model: str = ""
prompt_hash: str = "" # Vihje räsi, mitte vihje ise
prompt_length: int = 0
# Vastus
response_id: str = ""
output_length: int = 0
input_tokens: int = 0
output_tokens: int = 0
# Modereerimine
input_flagged: bool = False
output_flagged: bool = False
# Metaandmed
duration_ms: int = 0
status: str = "success"
error: Optional[str] = None
def to_json(self) -> str:
return json.dumps(asdict(self), ensure_ascii=False)
Täielik auditeerimissüsteem
Klient, mis kasutab seda struktuuri, aheldab sisendi modereerimise, API päringu, väljundi modereerimise ja kirjutab igal juhul. Oluline sõna on ainult-lisamine (append-only): JSONL-fail avatakse lisamisrežiimis, mitte kunagi ümberkirjutamiseks, mis on tingimus, et logil oleks tõendusväärtus. Pane tähele märgistatud kirje teekonda – kirje salvestatakse enne erandi tõstmist, olekuga blocked_input. Blokeerimine jätab seega jälje täpselt nagu õnnestumine ja lõplik except-plokk garanteerib, et ükski viga, olenemata selle päritolust, ei jää märkamata.
import time
from openai import OpenAI
class AuditedClient:
"""Integreeritud auditeerimise jäljega OpenAI klient."""
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:
"""Lühendatud SHA-256 räsi auditeerimiseks."""
return hashlib.sha256(text.encode()).hexdigest()[:16]
def _save_audit(self, record: AuditRecord):
"""Salvestab auditeerimiskirje (ainult-lisamine)."""
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 päring automaatse auditeerimisega."""
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:
# Sisendi modereerimine
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("Sobimatu sisu sisendis")
# API päring
response = self.client.responses.create(
model=model,
input=input,
**kwargs
)
# Väljundi modereerimine
mod_out = self.client.moderations.create(
model="omni-moderation-latest",
input=response.output_text
)
record.output_flagged = mod_out.results[0].flagged
# Täida mõõdikud
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
# Kasutamine
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)
Selles näites ei jõua user_id-na edastatud meiliaadress kunagi faili: see räsitakse kohe, kui kirje konstrueeritakse. JSONL-fail sobib hästi alustamiseks ja ühe instantsi jaoks; niipea kui mitu protsessi kirjutavad paralleelselt, suuna see voog andmebaasi või logikogujasse.
Auditeerimise päringud
Logi, mida ei saa pärida, teenib ainult ketaruumi hõivamist. JSONL-vormingu reahaaval lugemine muudab kasutamise triviaalseks ja allpool olev aruanne võtab kokku kaetud perioodi, jaotuse õnnestumiste, vigade ja blokeeringute vahel, tokenite tarbimise ja keskmise latentsuse. Unikaalsete kasutajate arv põhineb räsidel, mis tõestab muu hulgas, et pseudonüümitud logi jääb täiuslikult analüüsitavaks.
import json
def read_audit(file: str = "audit.jsonl") -> list[dict]:
"""Loeb kõik auditeerimiskirjed."""
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:
"""Genereerib auditeerimisaruande."""
records = read_audit(file)
if not records:
return {"message": "Kirjeid pole"}
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))
Säilitamine ja arhiveerimine
Andmete määramata ajaks hoidmine on vastuolus säilitamise piiramise põhimõttega; liiga vara kustutamine jätab sind ilma tõenditest, mida võiksid vajada. Pööramine (rotation) lahendab selle dilemma: pärast sinu määratud kestust – siin üheksakümmend päeva – liiguvad kirjed aktiivsest failist dateeritud arhiivi, samal ajal kui jooksev logi kirjutatakse ümber, säilitades ainult hiljutised. Planeeri see funktsioon perioodiliseks ülesandeks ja vii retention_days kooskõlla poliitikaga, mille on kinnitanud sinu juriidiline nõustaja, mitte juhuslikult valitud väärtusega.
from datetime import datetime, timedelta
import shutil
import os
def archive_audit(file: str = "audit.jsonl",
retention_days: int = 90):
"""Arhiveerib ja puhastab vanad kirjed."""
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:
# Arhiveeri vanad
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")
# Kirjuta põhifail ümber hiljutistega
with open(file, "w", encoding="utf-8") as f:
for record in recent:
f.write(json.dumps(record, ensure_ascii=False) + "\n")
print(f"Arhiveeritud {len(archives)} kirjet faili {archive_name}")
print(f"Säilitatud {len(recent)} hiljutist kirjet")
Euroopa tehisintellekti määrus: mis muutub
Euroopa tehisintellekti määrus (AI Act) kehtestab kohustused, mis põhinevad sinu rakenduse riskitasemel. Loogika on astmeline: mida rohkem sinu süsteem inimeste elu mõjutab, seda rangemad on nõuded. KKK vestlusrobot, kokkuvõte või tõlge kuuluvad minimaalse riski alla ja nõuavad vaid põhilist läbipaistvust. Niipea kui tegemist on vestluse või meeleolu analüüsiga, liigud piiratud riski kategooriasse, kus on kohustus informeerida kasutajat, et ta suhtleb tehisintellektiga. Hüpe on järsk kõrge riski puhul – krediidiskooring, värbamine, meditsiiniline diagnostika – kus lisanduvad vastavushinnang, riskijuhtimine, koolitusandmete dokumenteerimine, täielik jälgitavus, inimjärelevalve ja täpsuse demonstreerimine. Teatud kasutusviisid, nagu sotsiaalne skoorimine või subliminaalne manipuleerimine, on puhtalt keelatud.
# Hinda oma rakenduse riskitaset
RISK_LEVELS = {
"minimal": {
"examples": ["KKK vestlusrobot", "teksti kokkuvõte", "tõlge"],
"obligations": ["Põhiline läbipaistvus"]
},
"limited": {
"examples": ["klienditeeninduse vestlusrobot", "meeleolu analüüs"],
"obligations": ["Informeeri kasutajat, et ta suhtleb tehisintellektiga"]
},
"high": {
"examples": ["krediidiskooring", "värbamine", "meditsiiniline diagnostika"],
"obligations": [
"Vastavushinnang",
"Riskijuhtimissüsteem",
"Dokumenteeritud koolitusandmed",
"Logimine ja täielik jälgitavus",
"Kohustuslik inimjärelevalve",
"Demonstreeritud täpsus ja töökindlus"
]
},
"unacceptable": {
"examples": ["sotsiaalne skoorimine", "subliminaalne manipuleerimine"],
"obligations": ["KEELATUD"]
}
}
Paiguta oma projekt sellesse võrestikku ausalt enne esimese koodirea kirjutamist: kõrge riskiga klassifitseeritud rakendus seab arhitektuurilisi piiranguid – ammendav logimine, inimkontrolli punkt – mida ei saa hiljem juurde liimida süsteemile, mis on ilma nendeta projekteeritud.
Vastavuse kontrollnimekiri
- Ainult-lisamise režiimis auditeerimise jälg ajatempliga
- Isikuandmete räsimine logides (mitte kunagi lahtises tekstis)
- Sisendite ja väljundite süstemaatiline modereerimine
- Ajakohastatud GDPR-i töötlemistegevuste register
- Määratletud säilitamis- ja arhiveerimispoliitika
- Tehisintellekti määruse riskitaseme hindamine tehtud
- Kasutajate informeerimine, et nad suhtlevad tehisintellektiga
- Inimjärelevalve mõjukate otsuste jaoks
Peamised punktid
- Auditeerimise jälg on regulatiivseks vastavuseks kohustuslik
- Logi ainult-lisamise režiimis: ära kunagi muuda olemasolevaid kirjeid
- Räsi kõik isikuandmed auditeerimislogides
- Euroopa tehisintellekti määrus liigitab rakendused riskitaseme järgi
- Rakenda automaatne modereerimine JA inimjärelevalve
- Määratle säilitamispoliitika ja arhiveeri regulaarselt
Testi oma teadmisi
Kakskümmend kaks API tundi: valideeri mehhanismid, mis hoiavad tootmist koos.
1. Miks migreeruda Responses API-le, mitte jääda Chat Completionsi juurde?
Vastus: See on OpenAI kaasaegne API: integreeritud vestluse oleku haldus, loomulikud tööriistad ja arendus, mis on sellele keskendunud – Chat Completions jääb toetuks, kuid on iganenud.
2. Kuidas valida API poolel Soli, Terra ja Luna vahel?
Vastus: gpt-5.6-sol nõudlike ülesannete jaoks, terra kulude ja kvaliteedi tasakaalu jaoks, luna majandusliku mahu jaoks – ja arutlustase (none→max) kohandatakse seejärel päringu kohta.
3. Mida garanteerib struktureeritud väljund?
Vastus: Väljund, mis vastab esitatud JSON skeemile – väljad, tüübid, struktuur – programmiliselt kasutatav ilma kaitsva parsimise või parandamiseta.
4. Mida teha 429 vea korral?
Vastus: Austa kiiruse piiranguid: proovi uuesti eksponentsiaalse tagasipöördumisega (ja jitteriga), piira katseid ja planeeri vooluahela katkestaja – mitte kunagi viivitamatut uuesti proovimise tsüklit.
5. Nimeta kaks hädavajalikku kaitset rakenduse turvalisuse poolel.
Vastus: Sisse tuleva ja välja mineva sisu modereerimine spetsiaalse API kaudu ning kaitse vihje süstimise (prompt injection) vastu: eralda juhised andmetest, valideeri väljundeid, piira avaldatud võimalusi.
Tootmine, turvalisus, vastavus: kursuse viimased kolm plokki teevad vahet prototüübi ja teenuse vahel – hoia neid kontrollnimekirjana.