Vaatimustenmukaisuus ja tarkastusjälki
Tällä sivulla
Vaatimustenmukaisuus ja tarkastusjälki
Tuotannossa olevissa tekoälysovelluksissa jäljitettävyys on välttämätöntä. Täydellinen tarkastusjälki suojaa sinua tarkastuksen, riitatilanteen tai häiriön aikana. Tämä oppitunti näyttää, miten toteutat vankan tarkastusjärjestelmän ja päättää kurssin yhdistämällä kaiken tähänastisen – lokituksen, moderoinnin ja tietosuojan – yhdeksi puolustettavaksi kokonaisuudeksi.
Miksi tarkastusjälki?
Neljä erillistä tarvetta kohtaavat samassa infrastruktuurissa. Ensinnäkin sääntelyvaatimusten noudattaminen: GDPR, Euroopan tekoälyasetus ja alan standardit edellyttävät kaikki, että pystyt osoittamaan, mitä järjestelmäsi tekee, ja näyttö ilman lokeja on arvoton. Toiseksi jäljitettävyys tiukassa mielessä – tieto siitä, kuka teki mitä, milloin ja millä tuloksella, jopa kuusi kuukautta myöhemmin. Vianetsintä hyötyy tästä päivittäin, sillä odottamattoman mallikäytöksen ymmärtäminen vaatii kutsun tarkkojen olosuhteiden palauttamista. Lopuksi vastuullisuus: tekoälyn tekemien päätösten dokumentointi on se, mikä mahdollistaa sinulle myöhemmin näyttää, että kiistanalainen suositus perustui valvottuun prosessiin.
Tarkastustietueen rakenne
Alla oleva dataclass on yhtä lailla sopimus kuin tietorakennekin. Se ryhmittää tunnisteet, sovelluskontekstin, pyynnön, vastauksen, moderointipäätöksen ja tekniset metatiedot. Kaksi valintaa ansaitsee huomiosi. Käyttäjätunniste esiintyy vain tiivistettynä (hash), ei koskaan selväkielisenä. Ja kehote (prompt) ei tallennu: vain sen tiiviste ja pituus tallennetaan. Tämä säilyttää kykysi todistaa, että kaksi kutsua koski samaa sisältöä, luomatta kuitenkaan arkistoa käyttäjiesi kirjoittamasta tekstistä.
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)
Täydellinen tarkastusjärjestelmä
Tätä rakennetta hyödyntävä asiakas ohjelmoi syötteen moderoinnin, API-kutsun, tulosteen moderoinnin ja kirjoittaa joka tapauksessa. Tärkeä sana on vain-liittäminen (append-only): JSONL-tiedosto avataan liittämistilassa, sitä ei koskaan kirjoiteta uudelleen alusta, mikä on edellytys sille, että lokilla on näyttöarvoa. Huomaa merkityn tietueen kulku – tietue tallennetaan ennen poikkeuksen heittämistä tilalla blocked_input. Esto jättää siis jäljen aivan kuten onnistuminenkin, ja viimeinen except-lohko takaa, ettei mikään virhe syystä tai toisesta pääse huomaamatta.
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)
Tässä esimerkissä user_id:nä annettu sähköpostiosoite ei koskaan päädy tiedostoon: se tiivistetään heti tietuetta luotaessa. JSONL-tiedosto toimii hyvin aloitusvaiheessa ja yksittäisessä instanssissa; heti kun useat prosessit kirjoittavat rinnakkain, ohjaa tämä virta tietokantaan tai lokinkerääjään.
Tarkastuskyselyt
Loki, jota et voi kysellä, vie vain levytilaa. JSONL-muodon rivi riviltä lukeminen tekee hyödyntämisestä helppoa, ja alla oleva raportti tiivistää katetun ajanjakson, jakauman onnistumisten, virheiden ja estojen välillä, tokenkulutuksen sekä keskimääräisen viiveen. Unikien käyttäjien määrä perustuu tiivisteisiin, mikä osoittaa samalla, että pseudonymisoitu loki on täysin analysoitavissa.
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))
Säilytys ja arkistointi
Tietojen säilyttäminen loputtomiin on ristiriidassa säilytyksen rajoittamisen periaatteen kanssa; liian aikainen poistaminen vie sinulta tarvittavan näytön. Kierto ratkaisee tämän dilemman: asettamasi ajan – tässä 90 päivää – ylittyessä tietueet siirtyvät aktiivisesta tiedostosta päivättyyn arkistoon, kun taas nykyinen loki kirjoitetaan uudelleen sisältäen vain tuoreet tietueet. Ajoita tämä funktio jaksolliseksi tehtäväksi ja sovita retention_days oikeudellisen neuvonantajasi validoiman käytännön mukaan, äläkä satunnaisesti valittuun arvoon.
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")
Euroopan tekoälyasetus: mitä muuttuu
Euroopan tekoälyasetus (AI Act) asettaa velvoitteita sovelluksesi riskitason perusteella. Logiikka on porrastettu: mitä enemmän järjestelmäsi vaikuttaa ihmisten elämään, sitä tiukemmat vaatimukset. Usein kysytyistä kysymyksistä vastaava chatbot, yhteenveto tai käännös luokitellaan minimaaliseksi riskiksi ja vaatii vain perustason läpinäkyvyyttä. Heti kun kyseessä on keskustelu tai tunneanalyysi, siirrytään rajoitettuun riskiin, jolloin käyttäjälle on ilmoitettava, että hän on vuorovaikutuksessa tekoälyn kanssa. Hyppy on jyrkkä korkean riskin kohdalla – luottoluokitus, rekrytointi, lääketieteellinen diagnoosi – jolloin mukaan tulevat vaatimustenmukaisuuden arviointi, riskinhallinta, koulutusdatan dokumentointi, täydellinen jäljitettävyys, ihmisen valvonta ja tarkkuuden osoittaminen. Tietyt käyttötavat, kuten sosiaalinen pisteytys tai subliminaalinen manipulointi, ovat ehdottomasti kiellettyjä.
# 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"]
}
}
Sijoita projektisi rehellisesti tähän ruudukkoon ennen ensimmäisen koodirivin kirjoittamista: korkean riskin sovellus asettaa arkkitehtonisia rajoitteita – tyhjentävä lokitus, ihmisen valvontapiste – joita ei voi jälkikäteen liittää järjestelmään, joka on suunniteltu ilman niitä.
Vaatimustenmukaisuuden tarkistuslista
- Vain-liitettävä tarkastusjälki aikaleimalla
- Henkilötietojen tiivistäminen lokeissa (ei koskaan selväkielisenä)
- Syötteiden ja tulosteiden systemaattinen moderointi
- Ajantasainen GDPR:n mukainen käsittelytoimien rekisteri
- Määritelty säilytys- ja arkistointikäytäntö
- Tekoälyasetuksen mukainen riskitason arviointi suoritettu
- Käyttäjille ilmoittaminen tekoälyvuorovaikutuksesta
- Ihmisen valvonta vaikutuksellisissa päätöksissä
Keskeiset asiat
- Tarkastusjälki on pakollinen sääntelyvaatimusten noudattamiseksi
- Lokita vain-liitettävässä tilassa: älä koskaan muokkaa olemassa olevia tietueita
- Tiivistä kaikki henkilötiedot tarkastuslokeissa
- Euroopan tekoälyasetus luokittelee sovellukset riskitason mukaan
- Toteuta automaattinen moderointi JA ihmisen valvonta
- Määritä säilytyskäytäntö ja arkistoi säännöllisesti
Testaa tietämyksesi
Kaksikymmentäkaksi API-oppituntia: validoi mekanismit, jotka pitävät tuotannon koossa.
1. Miksi siirtyä Responses API:hun eikä jäädä Chat Completionsiin?
Vastaus: Se on OpenAI:n moderni API: integroitu keskustelutilan hallinta, natiivit työkalut ja kehitys keskittyy siihen – Chat Completions pysyy tuettuna, mutta on vanhentumassa.
2. Miten valitset Solin, Terran ja Lunan välillä API-puolella?
Vastaus: gpt-5.6-sol vaativiin tehtäviin, terra kustannus-laatu-tasapainoon, luna taloudellisiin volyymeihin – ja päättelytasoa (none→max) säädetään sitten pyyntökohtaisesti.
3. Mitä Strukturoitu tuloste takaa?
Vastaus: Annettuun JSON-skeemaan mukautuvan tulosteen – kentät, tyypit, rakenne – jonka ohjelma voi hyödyntää ilman puolustavaa jäsennystä tai korjausta.
4. Mitä teet kohdatessasi 429-virheen?
Vastaus: Kunnioita nopeusrajoituksia: yritä uudelleen eksponentiaalisella viiveellä (ja jitterillä), rajoita yrityksiä ja suunnittele katkaisija – ei koskaan välitöntä silmukkaa.
5. Nimeä kaksi välttämätöntä suojaa sovellusturvallisuuden puolella.
Vastaus: Saapuvan ja lähtevän sisällön moderointi omistetun API:n kautta ja suojaus kehoteinjektioita vastaan: erota ohjeet datasta, validoi tulosteet, rajoita paljastettuja ominaisuuksia.
Tuotanto, turvallisuus, vaatimustenmukaisuus: kurssin viimeiset kolme osiota tekevät eron prototyypin ja palvelun välillä – pidä ne tarkistuslistana.