Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

A/B-testning och affärsmått

Lektion 12 av 16 Uppdaterad 2 november 2026 Avancerad
På denna sida
  1. Bortom förlustfunktion: Att mäta affärspåverkan
  2. Att sätta upp ett A/B-test
  3. Att välja rätt affärsmått
  4. Att samla in mätvärden
  5. Att vänta på statistisk signifikans
  6. Att skala upp gradvis
  7. Viktiga punkter

Uppdatering 2 november 2026 — Tillgänglighet för finjustering. OpenAIs självbetjäningslösning för finjustering avvecklas: sedan den 7 maj 2026 kan organisationer som aldrig har använt tjänsten inte längre skapa jobb; sedan den 2 juli måste du ha använt en finjusterad modell under de senaste 60 dagarna; och från och med den 6 januari 2027 kommer ingen kund att kunna starta nya jobb. Redan tränade modeller förblir användbara tills deras basmodell tas ur bruk. Denna kurs är fortfarande användbar för att förstå och utnyttja en befintlig modell; för nya projekt bör du prioritera prompt engineering, RAG och utvärderingar.

Bortom förlustfunktion: Att mäta affärspåverkan

Träningsförlust och kvalitetspoäng räcker inte. Det som verkligen spelar roll är effekten av din finjusterade modell på dina affärsmässiga nyckeltal (KPI:er): kundnöjdhet, lösningstid och konverteringsgrad. En modell kan generera svar som dina granskare finner eleganta, samtidigt som den ökar eskaleringsfrekvensen till dina mänskliga agenter. Det andra talet avgör projektets framtid, inte det första.

Att sätta upp ett A/B-test

Ett A/B-test jämför två varianter under verkliga förhållanden med autentisk trafik. Grupp A, kontrollgruppen, får svar från basmodellen med din optimerade prompt; Grupp B, testgruppen, får svar från den finjusterade modellen. Användare tilldelas slumpmässigt till båda grupperna, och du mäter resultaten med samma mått. Hela övningens giltighet hänger på denna tilldelning: om Grupp B av en slump får de enklaste förfrågningarna, mäter dess skenbara överlägsenhet ingenting annat än tur.

Funktionen choisir_variante löser detta problem genom att hasha användar-ID:t. Detta tillvägagångssätt garanterar att samma användare alltid ser samma variant – vilket är avgörande, eftersom växling mellan sessioner skulle utsätta personen för två svarsstilar och snedvrida deras nöjdhetsbetyg. Det ger en statistiskt balanserad fördelning när volymen är tillräcklig, och det förblir reproducerbart: att köra beräkningen igen senare ger exakt samma grupper, vilket låter dig beräkna om ett glömt mått utan att starta om testet.

import random
import hashlib
from openai import OpenAI

client = OpenAI()

MODELE_BASE = "gpt-5.6-luna"
MODELE_FT = "ft:gpt-5.6-luna:org::suffix:xxxxxxxx"
PROMPT_BASE = "You are a professional customer support assistant..."

def choisir_variante(user_id: str, pourcentage_test: int = 50) -> str:
    """Assigns a user to group A or B deterministically."""
    h = int(hashlib.md5(user_id.encode()).hexdigest(), 16)
    return "B" if (h % 100) < pourcentage_test else "A"

def repondre(user_id: str, question: str) -> dict:
    """Responds with the correct model based on the A/B group."""
    variante = choisir_variante(user_id)

    if variante == "A":
        response = client.responses.create(
            model=MODELE_BASE,
            instructions=PROMPT_BASE,
            input=question
        )
    else:
        response = client.responses.create(
            model=MODELE_FT,
            input=question
        )

    return {
        "variante": variante,
        "modele": MODELE_BASE if variante == "A" else MODELE_FT,
        "reponse": response.output_text,
        "user_id": user_id
    }

Att välja rätt affärsmått

De indikatorer du ska spåra beror helt på vad din assistent är tänkt att leverera, och varje användningsområde har sina egna.

För en kundtjänst svarar lösningsgraden vid första kontakten på den mest konkreta frågan: behövde användaren kontakta supporten igen? CSAT-poängen, ett nöjdhetsbetyg på 1–5 som samlas in efter interaktionen, fångar stämningar som automatiserade mått missar. Lösningstiden mäter den totala varaktigheten för utbytet, och eskaleringsgraden – den del av konversationerna som överförs till en människa – ses som ett erkännande av modellmisslyckande för de berörda fallen. En lyckad finjustering sänker vanligtvis båda dessa samtidigt.

För en försäljningschatbot flyttas resonemanget längre ner i flödet. Konverteringsgraden räknar konversationer som leder till ett köp eller ett möte; engagemangsgraden, uttryckt som det genomsnittliga antalet meddelanden per konversation, kräver noggrann tolkning eftersom ett längre utbyte kan signalera antingen intresse eller missförstånd; studsgraden (bounce rate) isolerar användare som lämnar efter det första meddelandet, ofta för att det första svaret missade målet.

För en klassificerings- eller extraheringsuppgift återvänder du till den klassiska trion. Precision anger procentandelen korrekta klassificeringar, recall (minne) anger procentandelen positiva fall som faktiskt upptäcktes, och F1-poängen, det harmoniska medelvärdet av båda, förhindrar att du nöjer dig med en modell som aldrig förutsäger den sällsynta klassen bara för att undvika fel.

Att samla in mätvärden

Dessa indikatorer är värdelösa om de lever i tre separata kalkylblad. En enda insamlare, som matas vid varje interaktion, håller varianten tillsammans med måttet och möjliggör skapandet av en jämförande rapport med ett enda kommando. Klassen ABTracker nedan gör detta minimala arbete: den loggar, grupperar sedan efter variant och beräknar medelvärden och procentsatser.

import datetime

class ABTracker:
    """Metric collector for A/B testing."""

    def __init__(self):
        self.events = []

    def log_interaction(
        self,
        user_id: str,
        variante: str,
        question: str,
        reponse: str,
        metriques: dict
    ):
        """Records an interaction with its metrics."""
        self.events.append({
            "timestamp": datetime.datetime.now().isoformat(),
            "user_id": user_id,
            "variante": variante,
            "question": question,
            "reponse": reponse,
            **metriques
        })

    def rapport(self) -> dict:
        """Generates a comparative A vs B report."""
        groupes = {"A": [], "B": []}
        for e in self.events:
            groupes[e["variante"]].append(e)

        rapport = {}
        for variante, events in groupes.items():
            if not events:
                continue
            rapport[variante] = {
                "nb_interactions": len(events),
                "csat_moyen": self._moyenne(events, "csat"),
                "resolution_premier_contact": self._taux(events, "resolu"),
                "temps_moyen_sec": self._moyenne(events, "temps_resolution"),
            }

        return rapport

    def _moyenne(self, events, cle):
        vals = [e[cle] for e in events if cle in e and e[cle] is not None]
        return sum(vals) / len(vals) if vals else None

    def _taux(self, events, cle):
        vals = [e[cle] for e in events if cle in e]
        return sum(vals) / len(vals) * 100 if vals else None

tracker = ABTracker()

Att vänta på statistisk signifikans

Dra inga slutsatser för tidigt. Efter tjugo interaktioner per grupp har ett CSAT-gap på 0,4 poäng inget värde: tre nöjda kunder räcker för att producera det. Du behöver tillräckligt många interaktioner för att resultaten ska vara signifikanta, och riktvärdena nedan ger dig en uppfattning om storleksordningen att sikta på innan du ens tittar på siffrorna.

100
Minimum per group
500+
For reliable results
p < 0.05
Significance threshold

När du når den volymen avgör ett statistiskt test åt dig. Mann-Whitney-testet fungerar bra för nöjdhetsscore, som är ordinella betyg som sällan är normalfördelade. Dess p-värde besvarar en exakt fråga: vad är sannolikheten att observera ett så stort gap om de två modellerna egentligen var lika? Under 0,05 blir hypotesen om enkel slump svår att försvara.

from scipy import stats

def test_significativite(scores_a: list[float], scores_b: list[float]):
    """Tests whether the difference between A and B is significant."""
    stat, p_value = stats.mannwhitneyu(scores_a, scores_b, alternative="two-sided")

    moy_a = sum(scores_a) / len(scores_a)
    moy_b = sum(scores_b) / len(scores_b)

    print(f"Mean A: {moy_a:.3f}")
    print(f"Mean B: {moy_b:.3f}")
    print(f"p-value: {p_value:.4f}")

    if p_value < 0.05:
        gagnant = "B (fine-tuned)" if moy_b > moy_a else "A (base)"
        print(f"Significant difference — {gagnant} is better")
    else:
        print("No significant difference")

Att skala upp gradvis

Även ett lyckat test motiverar inte att växla all trafik över en natt: ett fel som bara dyker upp en gång på tusen förblir osynligt i ett urval men blir mycket synligt vid full volym. Gå framåt i etapper på en vecka och kontrollera dina mått vid varje steg innan du öppnar nästa.

  1. Fas 1 (1 vecka): 10 % av trafiken på den finjusterade modellen
  2. Fas 2 (1 vecka): 30 % om måtten är positiva
  3. Fas 3 (1 vecka): 50 % för huvud-A/B-testet
  4. Fas 4: 100 % om testet är övertygande

Om en fas försämrar dina mått, gå tillbaka till den föregående istället för att öppna nästa i hopp om att talet ska återhämta sig av sig självt. En vecka spenderad på att förstå varför kostar alltid mindre än en månad med trafik som betjänas av en besvikande modell.

Viktiga punkter

  • Affärsmått är viktigare än träningsförlust
  • Använd deterministisk hashning för A/B-tilldelning
  • Vänta på statistisk signifikans innan du drar slutsatser (p < 0,05)
  • Distribuera gradvis: 10 %, 30 %, 50 %, 100 %
  • Mät kostnader och latens utöver kvalitet