Ansvar och människa i loopen

«Människa i loopen» är inte ett tillstånd utan en skala, och den skillnaden är avgörande:

Att skriva «en människa granskar» i en policy räcker inte. Granskningen måste vara meningsfull, och det ställer fyra krav:

1. Granskaren har tid att faktiskt granska.
2. Granskaren har information nog att kunna avvika.
3. Granskaren har befogenhet att säga nej.
4. Att säga nej är inte dyrare för granskaren än att säga ja.

Brister någon av de fyra är granskningen en formalitet, och ansvaret har i praktiken flyttat till modellen.

Rubber-stamping är det vanligaste misslyckandet: granskaren godkänner nästan allt, eftersom AI:n har rätt oftast och tiden är knapp. Då finns människan där juridiskt men inte praktiskt.

Motmedel som faktiskt fungerar:

Den sista är den mest avslöjande och används i säkerhetskritiska branscher: skicka med jämna mellanrum in ett fall där AI:n har uppenbart fel och mät hur ofta det fångas.

Automatiseringsbias är den underliggande mekanismen: människor litar systematiskt mer på ett automatiserat förslag än på sin egen bedömning, särskilt under tidspress och när systemet brukar ha rätt. Den är väldokumenterad inom flyg och medicin, och den försvinner inte för att man är medveten om den.

Var människan ska placeras beror på konsekvensen:

Dokumentation. För varje beslut som påverkar någon ska följande gå att rekonstruera:

Den näst sista raden är guld värd: avvikelserna är exakt de fall där modellen och en kunnig människa är oense, och de är den bästa källan till förbättring som finns.

import hashlib, json, time
from dataclasses import dataclass, asdict
from enum import Enum

class Grad(Enum):
    IN_THE_LOOP = "människan beslutar"
    ON_THE_LOOP = "AI beslutar, människan kan avbryta"
    IN_COMMAND = "stickprov i efterhand"

def valj_grad(irreversibel: bool, betydande: bool) -> Grad:
    if irreversibel and betydande:
        return Grad.IN_THE_LOOP
    if betydande:
        return Grad.ON_THE_LOOP
    return Grad.IN_COMMAND

@dataclass
class Beslut:
    arende_id: str
    modellversion: str
    indata_hash: str
    modellens_forslag: str
    modellens_konfidens: float
    beslut: str
    beslutad_av: str
    avvek: bool
    motivering: str            # KRÄVS även vid godkännande
    tidpunkt: float
    utfall: str | None = None

def registrera(arende, forslag, konfidens, beslut, granskare, motivering, modellversion):
    if not motivering or len(motivering) < 15:
        raise ValueError("motivering krävs även när förslaget godkänns")
    return Beslut(
        arende_id=arende["id"],
        modellversion=modellversion,
        indata_hash=hashlib.sha256(
            json.dumps(arende, sort_keys=True).encode()).hexdigest()[:16],
        modellens_forslag=forslag, modellens_konfidens=konfidens,
        beslut=beslut, beslutad_av=granskare,
        avvek=(beslut != forslag), motivering=motivering, tidpunkt=time.time())

def granskningskvalitet(beslut: list[Beslut]) -> dict:
    n = len(beslut)
    avvek = sum(b.avvek for b in beslut)
    per_granskare = {}
    for b in beslut:
        d = per_granskare.setdefault(b.beslutad_av, {"n": 0, "avvek": 0})
        d["n"] += 1; d["avvek"] += int(b.avvek)
    return {
        "avvikelsefrekvens": round(avvek / max(n, 1), 4),
        "varning": "under 1 % — granskas troligen inte på riktigt" if avvek / max(n, 1) < 0.01 else "ok",
        "per_granskare": {k: round(v["avvek"] / v["n"], 3) for k, v in per_granskare.items()},
    }

# Planterade testfall: mät om granskningen faktiskt fångar fel
def plantera_testfall(ko, testfall, andel=0.02):
    """Blanda in fall där modellens förslag är känt felaktigt."""
    import random
    ut = list(ko)
    for t in testfall:
        if random.random() < andel:
            ut.insert(random.randrange(len(ut) + 1), t | {"_test": True})
    return ut

def fangstgrad(beslut, testfall_id):
    t = [b for b in beslut if b.arende_id in testfall_id]
    return round(sum(b.avvek for b in t) / max(len(t), 1), 3)
# < 0.8 betyder att granskningen missar fel som den borde fånga