Atbilstība un revīzijas žurnāls
Šajā lapā
Atbilstība un revīzijas žurnāls
AI lietojumprogrammām ražošanas vidē izsekojamība ir būtiska. Pilnīgs revīzijas žurnāls te pasargā inspekcijas, strīda vai incidenta gadījumā. Šajā nodarbībā tu uzzināsi, kā ieviest stabilu revīzijas sistēmu, noslēdzot kursu un apvienojot visu līdz šim izveidoto—reģistrēšanu, moderāciju un datu aizsardzību—vienotā, aizstāvamā sistēmā.
Kāpēc revīzijas žurnāls?
Četras atšķirīgas vajadzības saplūst vienā infrastruktūrā. Pirmkārt, normatīvā atbilstība: VDAR (GDPR), Eiropas AI akts un nozares standarti pieprasa, lai tu pierādītu, ko dara tava sistēma, un pierādījums bez žurnāliem ir bezvērtīgs. Otrkārt, izsekojamība šaurā nozīmē—zināt, kurš, ko, kad un ar kādu rezultātu darīja, pat pēc sešiem mēnešiem. Atkļūdošana no tā gūst labumu ikdienā, jo neparedzētas modeļa uzvedības sapratnei ir jāatjauno precīzi izsaukuma apstākļi. Visbeidzot, atbildība: AI pieņemto lēmumu dokumentēšana ir tas, kas ļaus tev, pienākot brīdim, parādīt, ka apstrīdēts ieteikums balstījās uz kontrolētu procesu.
Revīzijas ieraksta struktūra
Zemāk esošā dataclass ir tikpat daudz līgums, cik datu struktūra. Tā apvieno identifikatorus, lietojumprogrammas kontekstu, pieprasījumu, atbildi, moderācijas verdictu un tehnisko metadatu. Divi lēmumi ir pelnījuši tavu uzmanību. Lietotāja identifikators parādās tikai hashētā formā, nekad skaidrā tekstā. Un prompts netiek glabāts: tiek saglabāts tikai tā hash un garums. Tas saglabā tavu spēju pierādīt, ka divi izsaukumi attiecās uz vienu un to pašu saturu, nekad neizveidojot arhīvu ar to, ko tavi lietotāji ir rakstījuši.
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)
Pilnīga revīzijas sistēma
Klients, kas izmanto šo struktūru, secīgi veic ievades moderāciju, API izsaukumu, izvades moderāciju un katrā gadījumā veic ierakstu. Svarīgākais vārds ir tikai papildināms (append-only): JSONL fails tiek atvērts papildināšanas režīmā, nekad pārrakstīts, kas ir nosacījums, lai žurnālam būtu pierādījuma vērtība. Ņem vērā atzīmēta ieraksta ceļu—ieraksts tiek saglabāts pirms izņēmuma izraisīšanas, ar statusu blocked_input. Tādējādi bloķēšana atstāj pēdas tāpat kā veiksmīgs izpilde, un galīgais except bloks garantē, ka neviena kļūda, neatkarīgi no tās izcelsmes, nepaliek nepamanī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)
Šajā piemērā e-pasta adrese, kas nodota kā user_id, nekad nonāk failā: tā tiek hashēta brīdī, kad tiek konstruēts ieraksts. JSONL fails ir piemērots sākumam un vienam instancēm; tiklīdz vairāki procesi raksta paralēli, novirzi šo plūsmu uz datubāzi vai žurnālu vākšanas sistēmu.
Revīzijas vaicājumi
Žurnāls, ko nevari vaicāt, kalpo tikai vietas aizņemšanai diskā. JSONL formāta rindu pa rindu lasīšana padara izmantošanu triviālu, un zemāk esošais pārskats apkopo aptverto periodu, sadalījumu starp veiksmēm, kļūdām un bloķējumiem, tokena patēriņu un vidējo latentumu. Unikālo lietotāju skaits balstās uz hashēm, kas starp citu pierāda, ka pseidonimizēts žurnāls paliek pilnībā analizējams.
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))
Glabāšana un arhivēšana
Datu glabāšana uz nenoteiktu laiku ir pretrunā ar glabāšanas ierobežojuma principu; pārāk ātra dzēšana te atņem pierādījumus, kas tev varētu būt nepieciešami. Rotācija atrisina šo dilemmu: pēc tevis noteikta ilguma—šeit deviņdesmit dienas—ieraksti pāriet no aktīvā faila uz datētu arhīvu, kamēr pašreizējais žurnāls tiek pārrakstīts, atstājot tikai jaunākos. Ieplāno šo funkciju kā periodisku uzdevumu un saskaņo retention_days ar politiku, ko apstiprinājis tavs juridiskais padomnieks, nevis nejauši izvēlētu vērtību.
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")
Eiropas AI akts: kas mainās
Eiropas AI akts (AI Act) uzliek saistības, kas balstītas uz tavas lietojumprogrammas riska līmeni. Loģika ir pakāpeniska: jo vairāk tava sistēma ietekmē cilvēku dzīves, jo stingrākas ir prasības. Bieži uzdoto jautājumu čatbots, kopsavilkums vai tulkojums ietilpst minimālā riska kategorijā un prasa tikai pamata pārredzamību. Tiklīdz ir saruna vai sentimentu analīze, tu pāriesi uz ierobežota riska kategoriju, ar pienākumu informēt lietotāju, ka viņš mijiedarbojas ar AI. Lēciens ir pēkšņs augsta riska gadījumā—kredītvērtējums, darbā pieņemšana, medicīniskā diagnostika—kur tiek pievienoti atbilstības novērtējums, risku pārvaldība, apmācības datu dokumentēšana, pilnīga izsekojamība, cilvēka uzraudzība un precizitātes pierādīšana. Noteikti izmantošanas veidi, piemēram, sociālā vērtēšana vai sublimināla manipulācija, ir stingri aizliegti.
# 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"]
}
}
Godīgi ievieto savu projektu šajā režģī pirms pirmās koda rindas rakstīšanas: lietojumprogramma, kas klasificēta kā augsta riska, uzliek arhitektūras ierobežojumus—izsmeļoša reģistrēšana, cilvēka kontroles punkts—kurus nevar pēc fakta piešūt sistēmai, kas dizainēta bez tiem.
Atbilstības kontrolsaraksts
- Tikai papildināms revīzijas žurnāls ar laika zīmogu
- Personas datu hashēšana žurnālos (nekad skaidrā tekstā)
- Sistemātiska ievades un izvades moderācija
- Atjaunināts VDAR apstrādes darbību reģistrs
- Definēta glabāšanas un arhivēšanas politika
- Veikts AI akta riska līmeņa novērtējums
- Lietotāju informēšana par mijiedarbību ar AI
- Cilvēka uzraudzība ietekmīgiem lēmumiem
Galvenās atziņas
- Revīzijas žurnāls ir obligāts normatīvajai atbilstībai
- Reģistrē tikai papildināšanas režīmā: nekad nemaini esošos ierakstus
- Hashē visus personas datus revīzijas žurnālos
- Eiropas AI akts klasificē lietojumprogrammas pēc riska līmeņa
- Ievies automātisku moderāciju UN cilvēka uzraudzību
- Definē glabāšanas politiku un regulāri arhivē datus
Pārbaudi savas zināšanas
Divdesmit divas API nodarbības: apstiprini mehānismus, kas notur ražošanas vidi.
1. Kāpēc pāriet uz Responses API, nevis palikt pie Chat Completions?
Atbilde: Tā ir OpenAI modernā API: integrēta sarunu stāvokļa pārvaldība, natīvi rīki un evolūcija, kas fokusēta uz to—Chat Completions paliek atbalstīts, bet ir novecojis.
2. Kā izvēlēties starp Sol, Terra un Luna API pusē?
Atbilde: gpt-5.6-sol prasīgām uzdevumiem, terra izmaksu/kvalitātes līdzsvaram, luna ekonomiskam apjomam—un spriešanas līmenis (none→max) tiek pielāgots katram pieprasījumam.
3. Ko garantē strukturētā izvade (Structured Output)?
Atbilde: Izvadi, kas atbilst nodrošinātajai JSON shēmai—lauki, tipi, struktūra—ko programma var izmantot bez aizsardzības parsēšanas vai labošanas.
4. Ko darīt, saskaroties ar 429 kļūdu?
Atbilde: Ievēro ātruma ierobežojumus: atkārto ar eksponenciālu atkāpšanos (un troksni), ierobežo mēģinājumus un plāno ķēdes pārtraucēju—nekad tūlītēju atkārtošanas cilpu.
5. Nosauc divas neatņemamas aizsardzības lietojumprogrammas drošības pusē.
Atbilde: Ienākošā/izejošā satura moderācija, izmantojot specializēto API, un aizsardzība pret promptu injicēšanu: izolē instrukcijas no datiem, validē izvades, ierobežo eksponētās spējas.
Ražošana, drošība, atbilstība: pēdējie trīs kursa bloki izšķir starp prototipu un servisu—glabā tos kā kontrolsarakstu.