Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Atitiktis ir audito takas

Paskaita 22 iš 22 Atnaujinta 2026 m. liepos 29 d. Kūrėjas
Šiame puslapyje
  1. Atitiktis ir audito takas
  2. Kodėl reikia audito tako?
  3. Audito įrašo struktūra
  4. Pilna audito sistema
  5. Audito užklausos
  6. Saugojimo trukmė ir archivavimas
  7. Europos dirbtinio intelekto aktas: kas keičiasi
  8. Atitikties kontrolinis sąrašas
  9. Svarbiausi punktai
  10. Patikrink savo žinias

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šą.