Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Vaatimustenmukaisuus ja tarkastusjälki

Oppitunti 22 / 22 Päivitetty 29. heinäkuuta 2026 Kehittäjä
Tällä sivulla
  1. Vaatimustenmukaisuus ja tarkastusjälki
  2. Miksi tarkastusjälki?
  3. Tarkastustietueen rakenne
  4. Täydellinen tarkastusjärjestelmä
  5. Tarkastuskyselyt
  6. Säilytys ja arkistointi
  7. Euroopan tekoälyasetus: mitä muuttuu
  8. Vaatimustenmukaisuuden tarkistuslista
  9. Keskeiset asiat
  10. Testaa tietämyksesi

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.