Atitiktis ir audito takas
Šiame puslapyje
Atitiktis ir audito takas
AI programoms, veikiančioms gamybinėje aplinkoje, atsekamumas yra būtinas. Pilnas audito takas tave apsaugo patikrinimo, ginčo ar incidento metu. Šioje pamokoje sužinosi, kaip įdiegti patikimą audito sistemą, užbaigdamas kursą ir sujungdamas viską, ką iki šiol sukūrei – registravimą, moderavimą ir duomenų apsaugą – į vieną, ginamą sistemą.
Kodėl reikia audito tako?
Keturi skirtingi poreikiai susilieja toje pačioje infrastruktūroje. Pirma, reguliavimo atitiktis: BDAR, Europos dirbtinio intelekto aktas ir pramonės standartai reikalauja, kad galėtumėte parodyti, ką daro jūsų sistema, o demonstravimas be žurnalų yra bevertis. Antra, atsekamumas griežtąja prasme – žinojimas, kas, kada ir su kokiu rezultatu ką nors padarė, net ir po šešių mėnesių. Derinimas kasdien naudojasi šia galimybe, nes norint suprasti netikėtą modelio elgseną, reikia atkurti tikslias užklausos sąlygas. Galiausiai, atsakomybė: AI priimtų sprendimų dokumentavimas leis tau, kai ateis laikas, parodyti, kad ginčytina rekomendacija buvo pagrįsta kontroliuojamu procesu.
Audito įrašo struktūra
Toliau pateikta dataclass yra tiek sutartis, tiek duomenų struktūra. Ji sugrupuoja identifikatorius, programos kontekstą, užklausą, atsakymą, moderavimo verdiktą ir techninius metaduomenis. Du pasirinkimai nusipelno tavo dėmesio. Naudotojo identifikatorius atsiranda tik maišos (hash) pavidalu, niekada grynu tekstu. Ir užuomina (prompt) nėra saugoma: saugoma tik jos maiša ir ilgis. Tai išlaiko tavo galimybę įrodyti, kad dvi užklausos buvo susijusios su tuo pačiu turiniu, niekada nesukuriant archyvo su tuo, ką rašė tavo naudotojai.
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)
Pilna audito sistema
Klientas, naudojantis šią struktūrą, nuosekliai atlieka įvesties moderavimą, API užklausą, išvesties moderavimą ir visais atvejais rašo į žurnalą. Svarbiausias žodis yra tik papildoma (append-only): JSONL failas atidaromas papildymo režimu, niekada neperrašomas, ir tai yra sąlyga, kad žurnalas turėtų įrodomąją vertę. Atkreipk dėmesį į pažymėto įrašo kelią – įrašas išsaugomas prieš išmetant išimtį, su būsena blocked_input. Taigi blokavimas palieka pėdsaką taip pat, kaip ir sėkmė, o galutinis except blokas garantuoja, kad jokia klaida, nesvarbu, iš kur ji kiltų, neliks nepastebėta.
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)
Šiame pavyzdyje el. pašto adresas, perduotas kaip user_id, niekada nepatenka į failą: jis sumaišomas (hash) iškart, kai sukuriamas įrašas. JSONL failas puikiai tinka pradžiai ir vienam egzemplioriui; kai tik keli procesai rašo lygiagrečiai, nukreipk šį srautą į duomenų bazę arba žurnalų rinktuvą.
Audito užklausos
Žurnalas, kurio negali užklausti, tarnauja tik vietos diske užimti. Eilutė po eilutės skaitomas JSONL formatas daro naudojimą trivialiu, o toliau pateikta ataskaita apibendrina aprėptą laikotarpį, pasiskirstymą tarp sėkmingų, klaidingų ir blokuotų užklausų, žetonų sunaudojimą ir vidutinę delsą. Unikalių naudotojų skaičius remiasi maišomis, kas atsitiktinai įrodo, kad pseudonimizuotas žurnalas lieka puikiai analizuojamas.
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))
Saugojimo trukmė ir archivavimas
Duomenų saugojimas neribotą laiką prieštarauja saugojimo apribojimo principui; per ankstyvas ištrynimas atima iš tavęs įrodymus, kurių gali prireikti. Rotacija išsprendžia šią dilemą: pasibaigus tavo nustatytam laikotarpiui – čia devyniasdešimt dienų – įrašai palieka aktyvų failą ir patenka į datuotą archyvą, o dabartinis žurnalas perrašomas paliekant tik naujausius įrašus. Suplanuok šią funkciją kaip periodinę užduotį ir suderink retention_days su politika, patvirtinta tavo teisininko, o ne atsitiktinai pasirinkta verte.
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")
Europos dirbtinio intelekto aktas: kas keičiasi
Europos dirbtinio intelekto aktas (AI Act) nustato įpareigojimus pagal tavo programos rizikos lygį. Logika yra laipsniška: kuo daugiau tavo sistema veikia žmonių gyvenimus, tuo griežtesni reikalavimai. DUK pokalbių robotas, santrauka ar vertimas priskiriami minimaliai rizikai ir reikalauja tik pagrindinio skaidrumo. Kai tik atsiranda pokalbis ar nuotaikų analizė, pereini prie ribotos rizikos, su įpareigojimu informuoti naudotoją, kad jis bendrauja su AI. Šuolis yra staigus didelės rizikos atveju – kredito vertinimas, įdarbinimas, medicininė diagnostika – kur pridedamas atitikties vertinimas, rizikos valdymas, mokymo duomenų dokumentavimas, pilnas atsekamumas, žmogaus priežiūra ir tikslumo įrodymas. Tam tikri naudojimo būdai, pavyzdžiui, socialinis vertinimas ar subliminali manipuliacija, yra griežtai draudžiami.
# 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"]
}
}
Sąžiningai įvertink savo projektą šioje lentelėje prieš rašydamas pirmąją kodo eilutę: programa, klasifikuojama kaip didelės rizikos, nustato architektūrinius apribojimus – išsamų registravimą, žmogaus kontrolės tašką – kurių negalima pridėti post factum prie sistemos, sukurtos be jų.
Atitikties kontrolinis sąrašas
- Audito takas tik papildymo režimu su laiko žyma
- Asmeninių duomenų maiša žurnaluose (niekada ne grynu tekstu)
- Sistemingas įvesties ir išvesties moderavimas
- Atnaujintas BDAR duomenų tvarkymo veiklos registras
- Apibrėžta saugojimo trukmės ir archivavimo politika
- Atliktas AI akto rizikos lygio vertinimas
- Informuoti naudotojus, kad jie bendrauja su AI
- Žmogaus priežiūra svarbiems sprendimams priimti
Svarbiausi punktai
- Audito takas yra privalomas reguliavimo atitikčiai užtikrinti
- Registruok tik papildymo režimu: niekada nemodifikuok esamų įrašų
- Sumaišyk visus asmeninius duomenis audito žurnaluose
- Europos dirbtinio intelekto aktas klasifikuoja programas pagal rizikos lygį
- Įdiek automatinį moderavimą IR žmogaus priežiūrą
- Apibrėžk saugojimo politiką ir reguliariai archyvuok duomenis
Patikrink savo žinias
Dvidešimt dvi API pamokos: patvirtink mechanizmus, kurie laiko gamybinę aplinką.
1. Kodėl verta pereiti prie Responses API, o ne likti ties Chat Completions?
Atsakymas: Tai šiuolaikinė OpenAI API: integruotas pokalbių būsenos valdymas, vietiniai įrankiai ir evoliucija, sutelkta į tai – Chat Completions lieka palaikoma, bet yra pasenusi.
2. Kaip pasirinkti tarp Sol, Terra ir Luna API pusėje?
Atsakymas: gpt-5.6-sol sudėtingoms užduotims, terra kainos ir kokybės balansui, luna ekonomiškiems dideliems kiekiams – o samprotavimo lygis (none→max) tada koreguojamas kiekvienai užklausai atskirai.
3. Ką garantuoja struktūrizuota išvestis (Structured Output)?
Atsakymas: Išvestį, atitinkančią pateiktą JSON schemą – laukus, tipus, struktūrą – kurią programa gali panaudoti be gynybinio analizavimo ar taisymo.
4. Ką daryti susidūrus su 429 klaida?
Atsakymas: Laikytis dažnio ribų: kartoti su eksponentine pauze (ir trikdžiu), apriboti bandymų skaičių ir numatyti grandinės pertraukiklį – niekada neatlikinėti momentinių kartojimų kilpos.
5. Įvardyk dvi būtinas apsaugas programos saugumo srityje.
Atsakymas: Gaunamo ir siunčiamo turinio moderavimas naudojant specializuotą API ir apsauga nuo užuominų injekcijų (prompt injection): atskirti instrukcijas nuo duomenų, tikrinti išvestis, riboti atskleistas galimybes.
Gamyba, saugumas, atitiktis: paskutiniai trys kurso blokai lemia skirtumą tarp prototipo ir paslaugos – laikyk juos kaip kontrolinį sąrašą.