Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Atbilstība un revīzijas žurnāls

Nodarbība 22 no 22 Atjaunota 2026. gada 29. jūlijs Programmētājs
Šajā lapā
  1. Atbilstība un revīzijas žurnāls
  2. Kāpēc revīzijas žurnāls?
  3. Revīzijas ieraksta struktūra
  4. Pilnīga revīzijas sistēma
  5. Revīzijas vaicājumi
  6. Glabāšana un arhivēšana
  7. Eiropas AI akts: kas mainās
  8. Atbilstības kontrolsaraksts
  9. Galvenās atziņas
  10. Pārbaudi savas zināšanas

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.