Liten modell eller stor?

Den största modellen är nästan alltid bäst på kvalitet — och nästan alltid fel val för alla uppgifter.

	Liten modell	Stor modell
Kostnad per anrop	1×	10–50×
Latens	0,3–1 s	2–10 s
Kan köras lokalt	ofta	sällan
Enkla uppgifter	lika bra	onödigt dyr
Flerstegsresonemang	sämre	märkbart bättre

Frågan är inte «vilken modell är bäst?» utan «vilken är den billigaste som klarar den här uppgiften?»

Och svaret varierar mellan deluppgifter i samma system. Att klassificera en fråga, omformulera en söktermin eller sammanfatta ett stycke klarar en liten modell utmärkt. Att resonera sig fram till varför en elev gjorde ett visst fel gör den inte.

Mät på din egen uppgift. Publika benchmarks säger förvånansvärt lite om just ditt fall. Bygg ett testset på 50–100 verkliga exempel med facit och kör alla kandidater mot det.

Storhet	Hur du mäter
Kvalitet	träffsäkerhet eller domarpoäng på ditt testset
Kostnad	kr per 1 000 anrop, med verkliga promptlängder
Latens	p50 och p95 — medelvärdet döljer de långsamma svaren
Tillförlitlighet	andel giltiga svar (t.ex. korrekt JSON)

Routing — låt en billig modell ta det den klarar:

Strategi	Hur
Regelbaserad	frågelängd, nyckelord, uppgiftstyp
Klassificerare	en liten modell avgör svårighetsgrad
Kaskad	liten modell först; eskalera vid låg konfidens

Kaskaden är den mest lönsamma och den enklaste att motivera: kör den lilla modellen, be den ange om den är osäker, och skicka bara de osäkra vidare. Går 70 % igenom på den lilla modellen har du sänkt kostnaden med ungefär två tredjedelar till nära oförändrad kvalitet.

Räkneexempel. Stor modell: 0,15 kr per anrop. Liten: 0,01 kr. 100 000 anrop i månaden.

Upplägg	Kostnad per månad
Allt till stor	15 000 kr
Allt till liten	1 000 kr (men sämre på de svåra)
Kaskad, 70 % klaras av liten	0,7·1 000 + 0,3·15 000 + 1 000 = 6 200 kr

Den sista raden räknar med att den lilla modellen körs på alla anrop (därav den avslutande 1 000) och att 30 % går vidare till den stora.

Andra vägar att sänka kostnaden, ofta innan du byter modell: kortare kontext, prompt-caching, färre steg i kedjan, och cache på hela svar för återkommande frågor.

import json, time

PRIS = {"liten": {"in": 2.0, "ut": 8.0}, "stor": {"in": 30.0, "ut": 150.0}}   # kr/M tokens

def kostnad(modell, in_tok, ut_tok):
    p = PRIS[modell]
    return (in_tok * p["in"] + ut_tok * p["ut"]) / 1e6

def jamfor(modeller, testset, kor):
    """Kör samma testset mot flera modeller och rapportera kvalitet, kostnad och latens."""
    rader = []
    for m in modeller:
        ratt = kr = 0.0
        tider = []
        for fall in testset:
            t0 = time.perf_counter()
            svar, in_tok, ut_tok = kor(m, fall["fraga"])
            tider.append(time.perf_counter() - t0)
            ratt += float(svar.strip() == fall["facit"].strip())
            kr += kostnad(m, in_tok, ut_tok)
        tider.sort()
        rader.append({"modell": m,
                      "kvalitet": round(ratt / len(testset), 3),
                      "kr_per_1000": round(kr / len(testset) * 1000, 2),
                      "p50_s": round(tider[len(tider) // 2], 2),
                      "p95_s": round(tider[int(0.95 * len(tider))], 2)})
    return rader

# Kaskad: liten modell först, eskalera vid osäkerhet
OSAKER = "Om du inte är säker, svara exakt: OSÄKER"

def kaskad(llm, fraga):
    svar = llm("liten", f"{OSAKER}\n\n{fraga}")
    if svar.strip() != "OSÄKER":
        return {"svar": svar, "modell": "liten"}
    return {"svar": llm("stor", fraga), "modell": "stor"}

# Kostnadsjämförelse per månad
anrop = 100_000
for namn, andel_stor in (("allt stort", 1.0), ("allt litet", 0.0), ("kaskad", 0.30)):
    liten_kr = anrop * 0.01 if namn != "allt stort" else 0
    stor_kr = anrop * andel_stor * 0.15
    print(f"{namn:<11} {liten_kr + stor_kr:>9,.0f} kr/mån")
# allt stort     15,000 kr/mån
# allt litet      1,000 kr/mån
# kaskad          5,500 kr/mån

Mät p95, inte bara medelvärdet. En modell med 1,2 s i snitt men 9 s p95 känns långsam för användaren, eftersom det är de långsamma svaren man minns.