Deel A · Module 05

Modelvarianten & keuze

Dense, MoE, multimodaal; welk model voor welke taak?

Zone: machine ± 20 min kern, met twee interactieve visuals

Leerdoelen

Na deze module kun je:

  • voorspellen wat er met totale parameters, actieve parameters, rekenwerk per token en geheugenbehoefte gebeurt als je van een dense model naar Mixture-of-Experts gaat, of als je het aantal gekozen experts (k) verandert;
  • voor een taak een modelklasse kiezen (klein/snel, middel, groot/reasoning) en die keuze onderbouwen met kwaliteit, latency, kosten per voltooide taak, context en beeldinvoer;
  • een routeringsregel opstellen waarbij een klein model de bulk doet en een groot model de moeilijke stappen, en uitrekenen wanneer dat geld bespaart.

Voorkennis-check

Twee vragen over eerdere modules. Fout? Lees die module eerst terug.

Waar zitten we?

Laag 1 van de stack: het model. Alles erboven (API, loop, harness) praat tegen één specifiek model, en de keuze welk model dat is bepaalt kosten, snelheid en gedrag van het hele systeem.

De stof in drie lagen

Kern ± 5 min lezen, plus de visuals

“Het model” bestaat niet. Modellen verschillen op een paar assen die samen bepalen wat een request kost en wat je terugkrijgt: de grootte (aantal parameters) en architectuur (dense of Mixture-of-Experts), de modaliteit (alleen tekst, of ook beeld), de denktijd (direct antwoorden, of eerst redeneren) en het contextvenster. Als engineer kies je zelden een architectuur; je kiest een klasse model en weegt kwaliteit tegen snelheid en prijs.

Schaal werkt, en kost per token

Parameters zijn de getallen (gewichten) die tijdens training zijn geleerd. Meer parameters, meer trainingsdata en meer rekenkracht geven een lagere fout, en dat verband is verrassend regelmatig (Kaplan et al., 2020). Een dense model gebruikt voor elk token alle parameters. Dubbel zo groot is dus ruwweg dubbel zo veel rekenwerk per token: trager en duurder.

Mixture-of-Experts: veel parameters, weinig rekenwerk

Een MoE-model knipt dat vast. Het feed-forward-blok van elke laag wordt vervangen door meerdere parallelle blokken, de experts, plus een kleine router. Per token en per laag kiest de router een paar experts (bij Mixtral twee van acht); alleen die rekenen mee, en hun uitvoer wordt gewogen opgeteld.

At every layer, for every token, a router network chooses two of these groups (the “experts”) to process the token and combine their output additively.

Zo heeft het model veel totale parameters (kennis, capaciteit) maar weinig actieve parameters per token (rekenwerk). Probeer het hieronder. Schakel tussen Dense en MoE, loop de tokens door de laag met de tijdlijn (klik een stap, of gebruik de pijltjestoetsen), en verander k. Let op drie dingen: welke experts oplichten, hoe de teller “actief per token” reageert, en dat de teller “totale parameters” niet beweegt.

  • Rekenwerk volgt de actieve parameters: Mixtral rekent per token met ruim een kwart van zijn parameters.
  • Geheugen volgt de totale parameters: welke experts het volgende token nodig heeft, weet je pas na het routeren. Alle experts moeten dus geladen zijn.
  • De router beslist per token en per laag, op basis van geleerde gewichten, niet per onderwerp of per document.

Of de Claude-modellen dense of MoE zijn, en hoeveel parameters ze hebben, is voor zover wij in de Anthropic-docs kunnen zien niet gepubliceerd. Hier gebruiken we daarom open modellen (Mixtral) als voorbeeld van het mechanisme, en de Claude-docs voor wat wél openbaar is: namen, contextvensters, relatieve snelheid en prijs.

Welk model voor welke taak?

In de praktijk draait het om afwegen. Vijf eisen trekken in verschillende richtingen: latency, kosten, kwaliteit, contextgrootte en of beeldinvoer nodig is. Hieronder kies je een taak, pas je de wegingen aan en zie je welke modelklasse het best past en waarom. Probeer eens bij “Classificeer support-tickets” de kwaliteit op cruciaal en de kosten op een beetje te zetten: waar kantelt het advies?

Twee dingen om bij de uitkomst te onthouden. Eén: de scores zijn didactisch, geen benchmark; je eigen eval op je eigen taak beslist (zie D3). Twee: concrete modelnamen verouderen snel. De Anthropic-docs zeggen het zelf zo:

Compare models on cost per completed task, not per token, because you pay for completed tasks.

De brug naar agents

Een agent is een loop die tientallen requests doet. Een keuze die per request klein lijkt, wordt dan een factor tien tot honderd. Daarom wordt modelkeuze in agent-systemen een ontwerpkeuze per stap: een klein model voor routering en classificatie, een groot model voor de moeilijke stappen, en subagents met een goedkoper model voor de bulkarbeid (C4, D1). Wat het kost: D5. Wat er in het contextvenster past en wat daar slecht in gaat: B4.

Verdieping mechanisme en bronnen

Scaling laws: waarom groter beter werkt, en wat “compute-optimaal” betekent

Kaplan et al. (OpenAI, 2020) vonden dat de trainingsfout van taalmodellen een machtswet volgt in modelgrootte, datasetgrootte en rekenkracht:

The loss scales as a power-law with model size, dataset size, and the amount of compute used for training, with some trends spanning more than seven orders of magnitude.

Hun advies was om bij een vast rekenbudget vooral het model groter te maken. Hoffmann et al. (DeepMind, 2022) corrigeerden dat na het trainen van meer dan 400 modellen: model en data horen samen op te schalen.

for every doubling of model size the number of training tokens should also be doubled.

Hun model Chinchilla had 70 miljard parameters (kleiner dan Gopher met 280 miljard) en zo veel meer data dat het bij hetzelfde trainingsbudget beter presteerde. Voor jou als gebruiker is het gevolg dat “meer parameters” geen betrouwbare maat is voor kwaliteit: hoeveel data en hoe lang er getraind is, telt evenzeer. Ook zegt de paper dat een compute-optimaal kleiner model goedkoper is voor inferentie. Zie ook A3 voor de trainingsfasen zelf.

MoE nader: de router, load balancing en wat experts niet zijn

Het idee komt van Shazeer et al. (2017): een sparsely-gated MoE-laag met een trainbaar gating-netwerk dat per voorbeeld een schaarse combinatie van experts kiest. Dat levert veel meer capaciteit zonder evenredig meer rekenwerk:

A trainable gating network determines a sparse combination of these experts to use for each example.

Mixtral past het toe in een moderne decoder-only transformer: elk feed-forward-blok is vervangen door 8 experts met top-2 routering. De paper beschrijft de rekenregel: de softmax gaat alleen over de k grootste logits, en k is de knop voor het rekenwerk:

The value of K – the number of experts used per token – is a hyper-parameter that modulates the amount of compute used to process each token.

Jiang et al., Mixtral of Experts (2024)

Load balancing. Een router die zijn eigen voorkeuren versterkt, is een bekend probleem. Zonder tegenmaatregel kiest hij steeds dezelfde experts:

This imbalance is self-reinforcing, as the favored experts are trained more rapidly and thus are selected even more by the gating network.

Shazeer et al., Outrageously Large Neural Networks (2017)

Shazeer et al. lossen dat op met een extra term in de trainingsloss die ongelijke belasting straft. In de doe-opdracht meet je zelf zo’n belastingsmaat.

Experts zijn geen vakspecialisten. Het is verleidelijk om te denken dat expert 3 “de code-expert” is. Mixtral onderzocht dat expliciet, en vond dat niet:

Surprisingly, we do not observe obvious patterns in the assignment of experts based on the topic.

Jiang et al., Mixtral of Experts (2024)

Wel zagen ze structuur op tokenniveau (bijvoorbeeld inspringing in code die steeds bij dezelfde expert uitkomt). Experts specialiseren dus op iets wat niet makkelijk te benoemen valt.

Geheugen en batching. De paper is er eerlijk over dat de besparing niet gratis is:

The memory costs for serving Mixtral are proportional to its sparse parameter count, 47B, which is still smaller than Llama 2 70B.

Jiang et al., Mixtral of Experts (2024)

Ook noemt de paper dat MoE meer geschikt is voor batched workloads waar je een goede rekenintensiteit haalt; de routering en het laden van meerdere experts per apparaat geven extra overhead.

Multimodaal: een beeld wordt een rij tokens

Een model dat beeld begrijpt, is meestal geen apart soort model. Het is dezelfde transformer die ook patches van een afbeelding als invoer krijgt. De Vision Transformer (ViT, Dosovitskiy et al., 2020) liet dit zien: knip het beeld in vierkante patches, projecteer elke patch lineair tot een vector (zoals een token-embedding), en voer de rij door een gewone transformer.

Image patches are treated the same way as tokens (words) in an NLP application.

De consequentie voor jou: een afbeelding kost tokens, en dus context en geld. Voor Claude beschrijven de docs de rekenregel:

Each patch is a 28×28-pixel block of the image, referred to as a visual token.

Zo kost een screenshot van 1000×1000 pixels 1.296 visuele tokens, en een van 1920×1080 pixels 2.691 (zie de berekening onder de motorkap). Wie veel screenshots naar een agent stuurt, zit snel aan duizenden tokens per beeld. Verklein beelden die geen extra detail nodig hebben. Hoe Claude intern beeld verwerkt, is niet gepubliceerd; wat de docs wel zeggen is dat alle huidige modellen beeldinvoer ondersteunen:

All current models support text and image input, text output, multilingual capabilities, vision, and tool use.

“Multimodaal” is dus voor Claude een eigenschap van het model, geen aparte klasse. Bij andere (vooral open) modellen is beeldinvoer wél een harde eis die je modelkeuze beperkt: controleer het.

Reasoning: meer inferentie-compute

Een reasoning-model rekent niet méér per token; het produceert meer tokens voordat het antwoordt. Volgens de Anthropic-docs:

When thinking is active, Claude works through the problem in its own words before answering: it restates what is being asked, tries approaches, checks intermediate results, and abandons paths that do not hold up.

Dat is gewone tekstgeneratie, dus het kost gewone output-tokens, en het kost tijd:

the tokens Claude spends reasoning are billed as output tokens, even when the thinking text isn’t returned to you

Anthropic, Thinking

Denk-tokens tellen ook mee voor max_tokens. Hoeveel het model denkt, wordt tegenwoordig niet meer met een vast budget ingesteld. Volgens de docs is die handmatige modus (“extended thinking” met budget_tokens) afgeschaft op nieuwere modellen en vervangen door adaptive thinking, waarbij het model zelf beslist hoeveel het denkt, gestuurd door de effort-parameter:

Adaptive thinking lets the model decide how much to think, steered by effort.

Anthropic, Models overview, opgehaald 17 november 2026

Voor modelkeuze betekent dit dat denktijd een tweede knop naast de modelklasse is, en dat de docs zelf zeggen dat die vaak de betere knop is:

Tuning effort is often a better lever than switching models.

Meer denken is niet altijd beter. Het kost latency en geld, en het hoeft niet te lonen voor een eenvoudige classificatie. Meet het op je eigen taak.

Contextvenster als modeleigenschap

Het contextvenster is het maximum aantal tokens (invoer en uitvoer samen) dat het model in één request kan verwerken; het verschilt per model. Volgens de models overview (17 november 2026) hebben de huidige Claude-modellen allemaal een venster van 1M tokens, de oudere Claude 4.5-generatie 200K. Zo’n venster is volgens de docs ruwweg 555.000 woorden op de huidige tokenizer. Voor open modellen ligt dat anders: Mixtral is getraind met een context van 32k tokens. Twee kanttekeningen. Eén: een groot venster is een limiet, geen garantie dat het model alles even goed gebruikt; hoe je de ruimte beheert is B4. Twee: elk token dat je meestuurt kost per request geld, ook als het venster ruim genoeg is.

Kleinere modellen en distillatie

Een klein model hoeft niet simpelweg een “afgeslankte versie” te zijn. Een bekende techniek is distillatie (Hinton et al., 2015): kennis van een groot model (of ensemble) comprimeren in een kleiner model dat goedkoper te draaien is.

it is possible to compress the knowledge in an ensemble into a single model which is much easier to deploy

Hoe de kleinere modellen van Anthropic of andere leveranciers precies gemaakt zijn, is niet iets wat wij uit de gebruikte bronnen kunnen halen. Behandel “klein” dus als een meetbare eigenschap (snelheid, prijs, score op jouw taak), niet als een garantie over de herkomst.

Modelkeuze als engineering-afweging

De Anthropic-docs hanteren twee startstrategieën. Efficiency-first: begin met het snelle, goedkope model, test grondig en ga alleen omhoog bij een aantoonbaar gat. Capability-first: begin met het sterkste model voor je taak en optimaliseer later omlaag. Dezelfde docs noemen de kleinste klasse bij uitstek voor gesloten werk:

For high-volume, latency-sensitive tasks such as classification, extraction, and routing

Anthropic, Models overview, beschrijving van Claude Haiku 5.5, opgehaald 17 november 2026

Kosten per voltooide taak, niet per token. Een duurder model kan met minder werk klaar zijn. In Anthropic’s eigen meting op een SWE-bench Pro-subset loste Claude Sonnet 5.5 (standaard-effort) 87,6% van de taken op voor $0,11 per opgeloste taak; Claude Opus 5.5 op low effort 87,4% voor $0,12, en Opus 5.5 op standaard-effort 92,8% voor $0,22 (Anthropic, Optimizing for cost and intelligence, opgehaald 17 november 2026; de scores zijn volgens de docs niet vergelijkbaar met de publieke leaderboard). De les is niet “gebruik Opus”, maar: meet kosten per opgeloste taak.

Modellen combineren. Dezelfde pagina beschrijft twee patronen. Bij de advisor draait een kleiner model de loop en vraagt het hulp aan een groter model bij moeilijke beslissingen. Bij de orchestrator plant een groot model en delegeert het bulkwerk aan goedkopere modellen. En een waarschuwing vooraf:

Tune one model before you add a second

Anthropic, Optimizing for cost and intelligence

Een combinatie loont volgens hun metingen alleen in specifieke gevallen (routinewerk met een lange kostenstaart, of werk dat groter is dan één contextvenster). Het patroon uit de Kern, “klein model voor routering en classificatie, groot voor de moeilijke stappen”, is dus een hypothese die je met een eval moet toetsen. Dat doe je in de doe-opdracht.

The bill is decided by the tasks the cheaper model fails, because a failed task still bills its tokens, then the retry, then whatever the failure costs downstream.

Anthropic, Optimizing for cost and intelligence
Onder de motorkap parameters narekenen, beeldtokens, cascade-kosten

1. Totale en actieve parameters van Mixtral 8x7B narekenen

Uit Table 1 van de Mixtral-paper (dim 4096, 32 lagen, 32 koppen van 128, 8 key/value-koppen, hidden_dim 14336, vocabulaire 32000, 8 experts, top-2) kun je de getallen uit de abstract zelf afleiden. Een expert is een SwiGLU-blok met drie matrices; het attention-deel heeft Q-, K-, V- en O-matrices. Normalisatiegewichten laten we weg (verwaarloosbaar).

params.py

# Mixtral 8x7B, Table 1 uit Jiang et al. 2024
dim, lagen, hoofd, koppen, kv, hidden, vocab, n_exp = 4096, 32, 128, 32, 8, 14336, 32000, 8

attn   = 2*dim*koppen*hoofd + 2*dim*kv*hoofd      # Q, O (dim x 4096) en K, V (dim x 1024)
expert = 3*dim*hidden                             # SwiGLU: drie matrices dim x hidden
router = dim*n_exp
emb    = 2*vocab*dim                              # invoer-embedding + uitvoerlaag

totaal = lagen*(attn + n_exp*expert + router) + emb
actief = lagen*(attn + 2*expert + router) + emb
print(f"totaal {totaal/1e9:.1f} mld, actief per token {actief/1e9:.1f} mld, aandeel {actief/totaal:.0%}")
print(f"één expert: {expert/1e6:.0f} M; FLOPs-verhouding t.o.v. dense met evenveel parameters: {actief/totaal:.2f}")

Uitvoer: totaal 46.7 mld, actief per token 12.9 mld, aandeel 28% en één expert: 176 M; FLOPs-verhouding t.o.v. dense met evenveel parameters: 0.28. De paper rondt af op 47B en 13B; onze som komt op 46,7 en 12,9 miljard uit. Rekenwerk per token is ruwweg 2 × actieve parameters FLOPs (één vermenigvuldiging en één optelling per gewicht). Dat is een vereenvoudiging: de attention over de context is niet meegeteld, en die groeit met de lengte van de prompt.

2. Wat een beeld kost

beeld.py

from math import ceil
def visuele_tokens(b, h):            # patches van 28x28 pixels (Anthropic vision-docs)
    return ceil(b/28) * ceil(h/28)

print(visuele_tokens(1000, 1000))     # 1296: komt overeen met de docs-tabel
print(visuele_tokens(1920, 1080))     # 2691: high-resolution tier, niet verkleind
print(visuele_tokens(200, 200))       # 64

Uitvoer: 1296, 2691, 64. Dat klopt met de tabel in de vision-docs voor 1000×1000, 1920×1080 (high-resolution tier, niet verkleind) en 200×200. Op de standaard-tier worden grote beelden eerst verkleind (maximaal 1.568 visuele tokens); de aanname hierboven geldt dus voor de high-resolution tier of voor beelden die niet verkleind worden.

3. Wanneer een cascade geld bespaart

Een cascade laat het kleine model alles doen en stuurt een deel naar het grotere model. Kosten per dag = N × c_klein + p × N × c_groot, met p het aandeel dat escaleert. De cascade is goedkoper dan alles naar het grote model zolang p < 1 − c_klein / c_groot. Met de prijzen uit de Anthropic models overview (17 november 2026; Haiku 5.5 tot 100K promptlengte, Sonnet 5.5):

cascade.py

PRIJS = {"klein": (0.10, 0.50), "middel": (2.00, 10.00)}   # $ per miljoen tokens (in, uit); Anthropic models overview, 17 nov 2026

def per_request(klasse, t_in, t_uit):
    p_in, p_uit = PRIJS[klasse]
    return (t_in * p_in + t_uit * p_uit) / 1e6

n, t_in, t_uit = 10_000, 500, 20                          # 10.000 tickets, 500 tokens in, 20 uit
alleen_middel = n * per_request("middel", t_in, t_uit)
alleen_klein  = n * per_request("klein", t_in, t_uit)
for p in (0.05, 0.15, 0.50):                              # aandeel dat naar het grotere model escaleert
    cascade = alleen_klein + p * alleen_middel            # het kleine model draait altijd, het grote alleen bij escalatie
    print(f"escalatie {p:>4.0%}: ${cascade:6.2f}  (alleen middel: ${alleen_middel:.2f}, alleen klein: ${alleen_klein:.2f})")
print(f"break-even escalatiepercentage: {1 - alleen_klein/alleen_middel:.0%}")

Uitvoer: bij 5% escalatie $1,20, bij 15% $2,40 en bij 50% $6,60, tegen $12,00 voor alles op het middelgrote model en $0,60 voor alles op het kleine; break-even bij 95%. Let op wat de som niet meeneemt: de fouten die het kleine model maakt en niet doorstuurt, en de extra latency van de tweede stap. Zie het citaat over “the tasks the cheaper model fails” hierboven.

4. Load balancing: de belastingsmaat van Shazeer

Shazeer et al. definiëren de importance van een expert als de som van zijn gate-waarden over een batch, en straffen ongelijkheid:

This loss is equal to the square of the coefficient of variation of the set of importance values, multiplied by a hand-tuned scaling factor

Shazeer et al., Outrageously Large Neural Networks (2017), sectie 4

De coëfficiënt van variatie is standaardafwijking gedeeld door gemiddelde; kwadrateren geeft var / mean². Een perfect gelijk verdeelde router geeft 0. Je meet het zelf in de doe-opdracht (spoor B).

Uitgewerkt voorbeeld: een MoE-laag in numpy

Dezelfde laag als in de visual: 8 tokens, 8 experts, top-2. De gewichten zijn willekeurig (seed 7), dus de keuzes betekenen niets; het mechanisme is wat telt. De uitvoer hieronder is exact wat python3 met numpy geeft, en de logits staan afgerond in data/modellen.json, zodat de visual dezelfde keuzes toont.

moe.py

import numpy as np

rng = np.random.default_rng(7)
tokens = ["De", " router", " kiest", " per", " token", " twee", " experts", "."]
d, n_exp, k = 8, 8, 2                      # embedding-dimensie, aantal experts, top-k

x = rng.normal(size=(len(tokens), d))      # "embeddings" van de tokens (willekeurig)
W_gate = rng.normal(size=(d, n_exp))       # de router: één lineaire laag
W_exp = rng.normal(size=(n_exp, d, d))     # elke expert: hier één kleine matrix

def moe_layer(x, k=2):
    logits = x @ W_gate                                   # (tokens, experts)
    top = np.argsort(logits, axis=1)[:, ::-1][:, :k]       # indices van de k grootste logits
    out = np.zeros_like(x)
    gates = np.zeros_like(logits)
    for t in range(len(x)):
        sel = logits[t, top[t]]
        w = np.exp(sel - sel.max()); w /= w.sum()          # softmax alleen over de top-k
        gates[t, top[t]] = w
        for e, we in zip(top[t], w):
            out[t] += we * np.tanh(x[t] @ W_exp[e])        # alleen gekozen experts rekenen
    return out, logits, top, gates

out, logits, top, gates = moe_layer(x)
for t, tok in enumerate(tokens):
    a, b = top[t]
    print(f"{tok!r:10} -> E{a+1} ({gates[t,a]:.2f}) + E{b+1} ({gates[t,b]:.2f})")
print("belasting per expert:", np.bincount(top.ravel(), minlength=n_exp))
print("expert-evaluaties:", len(tokens) * k, "i.p.v.", len(tokens) * n_exp)
print("gewichten tellen op tot 1:", np.allclose(gates.sum(axis=1), 1))

uitvoer

'De'       -> E3 (0.57) + E1 (0.43)
' router'  -> E1 (0.66) + E6 (0.34)
' kiest'   -> E6 (0.66) + E1 (0.34)
' per'     -> E6 (0.65) + E4 (0.35)
' token'   -> E5 (0.82) + E8 (0.18)
' twee'    -> E8 (0.78) + E2 (0.22)
' experts' -> E8 (0.90) + E3 (0.10)
'.'        -> E7 (0.69) + E4 (0.31)
belasting per expert: [3 1 2 2 1 3 1 3]
expert-evaluaties: 16 i.p.v. 64
gewichten tellen op tot 1: True
  1. De router is niets anders dan één lineaire laag: elk token (een vector van 8 getallen) wordt met een 8×8-matrix vermenigvuldigd tot 8 logits, één per expert.
  2. argsort sorteert oplopend; omdraaien en de eerste k nemen geeft de indices van de k grootste logits. Voor het token “ experts” zijn dat E8 en E3.
  3. De softmax gaat alleen over de gekozen k logits, zodat de gewichten optellen tot 1 (0,90 + 0,10). Wie over alle 8 zou nemen, krijgt kleinere gewichten die niet optellen tot 1.
  4. Alleen de gekozen experts rekenen: 8 tokens × 2 = 16 evaluaties in plaats van 64. Dit is de besparing, en het is ook de reden dat de uitvoer een gewogen som is.
  5. De belasting [3 1 2 2 1 3 1 3] telt 16 toewijzingen; ongelijk (E1, E6 en E8 krijgen er drie), en met 8 tokens zegt dat nog weinig. Bij duizenden tokens is dit precies wat load balancing moet vlak trekken.
Doe-opdracht

Meet een routeringsregel: klein tegenover groot (spoor A) of meet load balancing (spoor B)

Kies spoor A als je een API-key hebt, spoor B als je het zonder wilt doen of eerst het mechanisme wilt voelen. Beide passen in 30 tot 60 minuten.

Spoor A: kleine en grote klasse naast elkaar meten

  1. Installeer de SDK (pip install anthropic), zet ANTHROPIC_API_KEY en sla het script hieronder op als route_test.py. Het stuurt 10 classificatietaken en één lastige redeneertaak naar een klein en een groot model en meet latency en kosten. Controleer de modelnamen en prijzen in het script tegen de actuele models overview.

    route_test.py

    import time
    import anthropic
    
    client = anthropic.Anthropic()                       # leest ANTHROPIC_API_KEY
    KLEIN, GROOT = "claude-haiku-5-5", "claude-opus-5-5"
    PRIJS = {KLEIN: (0.10, 0.50), GROOT: (4.00, 20.00)}  # $ per miljoen tokens (in, uit); controleer de actuele pricing-pagina
    
    TICKETS = [  # (tekst, juist label)
        ("Mijn factuur is twee keer afgeschreven.", "billing"),
        ("De app crasht zodra ik een foto upload.", "bug"),
        ("Kan ik mijn abonnement per jaar betalen?", "billing"),
        ("Ik kan niet inloggen sinds de update.", "bug"),
        ("Hoe exporteer ik mijn data naar CSV?", "vraag"),
        ("Jullie knop 'Opslaan' doet niets op Safari.", "bug"),
        ("Wat kost het zakelijke pakket per gebruiker?", "billing"),
        ("Waar vind ik de API-documentatie?", "vraag"),
        ("Ik word steeds uitgelogd na vijf minuten.", "bug"),
        ("Kunnen jullie ook Excel-bestanden importeren?", "vraag"),
    ]
    MOEILIJK = ("Een klant meldt dat zijn export 'soms' dubbele regels bevat. Logs: export draait via twee workers "
                "die dezelfde queue lezen; retries na timeout na 30 s; een export duurt gemiddeld 28 s. "
                "Geef de meest waarschijnlijke oorzaak en een fix in maximaal vier zinnen.")
    
    def vraag(model, prompt):
        t0 = time.perf_counter()
        r = client.messages.create(model=model, max_tokens=600, messages=[{"role": "user", "content": prompt}])
        dt = time.perf_counter() - t0
        tekst = "".join(b.text for b in r.content if b.type == "text").strip()
        p_in, p_uit = PRIJS[model]
        kosten = (r.usage.input_tokens * p_in + r.usage.output_tokens * p_uit) / 1e6
        return tekst, dt, kosten
    
    for model in (KLEIN, GROOT):
        goed, tijd, geld = 0, 0.0, 0.0
        for tekst, label in TICKETS:
            antw, dt, k = vraag(model, f"Classificeer dit ticket als billing, bug of vraag. Antwoord met één woord.\n\n{tekst}")
            goed += label in antw.lower(); tijd += dt; geld += k
        print(f"{model}: {goed}/10 goed, {tijd/10:.1f} s gemiddeld, ${geld:.5f} totaal")
        antw, dt, k = vraag(model, MOEILIJK)
        print(f"  moeilijke taak: {dt:.1f} s, ${k:.5f}\n  {antw}\n")
  2. Draai het. Noteer per model: aantal goed, gemiddelde latency, totale kosten, en lees de antwoorden op de moeilijke taak naast elkaar.
  3. Breid de set uit tot 30 eigen taken uit je werk (met een juist label waar dat kan). Welk deel kan het kleine model aan?
  4. Schrijf je routeringsregel op als beslisregel in één alinea: welke taken gaan naar welke klasse, wanneer escaleer je (bijvoorbeeld bij een label buiten het schema, of een onzekerheidsvraag), en wat is je aanname over het aandeel escalaties? Reken met de som uit de motorkap uit of de cascade goedkoper is dan alles groot.

Spoor B: load balancing meten in numpy (zonder API-key)

  1. Sla het script op als balans.py en draai het met python3 balans.py (alleen numpy nodig). Het routeert 4096 willekeurige tokens met top-2 en meet per expert de belasting en de importance-maat van Shazeer (CV² = var / mean²).

    balans.py

    import numpy as np
    rng = np.random.default_rng(7)
    d, n_exp, k, n_tok = 8, 8, 2, 4096
    W_gate = rng.normal(size=(d, n_exp))
    x = rng.normal(size=(n_tok, d))
    
    def balans(logits, k):
        top = np.argsort(logits, axis=1)[:, ::-1][:, :k]
        sel = np.take_along_axis(logits, top, axis=1)
        w = np.exp(sel - sel.max(axis=1, keepdims=True)); w /= w.sum(axis=1, keepdims=True)
        importance = np.zeros(logits.shape[1]); np.add.at(importance, top.ravel(), w.ravel())   # som van gate-waarden per expert
        load = np.bincount(top.ravel(), minlength=logits.shape[1])                              # aantal tokens per expert
        cv2 = lambda v: v.var() / v.mean() ** 2                                                  # kwadraat van de variatiecoëfficiënt
        return load, importance, cv2(importance), cv2(load)
    
    for bias in (0.0, 1.0, 3.0):                      # extra voorkeur voor expert 1: een router die "voortrekt"
        logits = x @ W_gate
        logits[:, 0] += bias
        load, imp, cv_imp, _ = balans(logits, k)
        print(f"bias {bias}: load {load.tolist()}  CV²(importance)={cv_imp:.3f}")
  2. De regel logits[:, 0] += bias simuleert een router die expert 1 voortrekt. Voorspel eerst: bij welke bias krijgt expert 1 meer dan een derde van alle toewijzingen? Draai daarna.
  3. Voeg een tweede maat toe: het aandeel tokens dat geen enkele van de experts 5 tot 8 haalt, bij bias 3. Wat zegt dat over de ongebruikte capaciteit?
Verwacht resultaat

Spoor A. Het kleine model is merkbaar sneller en op de 10 eenvoudige tickets vermoedelijk (bijna) even goed; de kosten liggen een orde van grootte lager, want de prijs per token verschilt ruwweg een factor 40 (docs, 17 november 2026). Op de lastige taak zie je het verschil eerder in de kwaliteit van de redenering dan in een label. Hoe groot de verschillen zijn, verschilt per model en per run; het script is gecontroleerd met een nagebootste client, niet met een echte API-aanroep. Een typische routeringsregel: “alle tickets naar de kleine klasse; als het antwoord niet in het label-schema valt of de klant een foutmelding met logs meestuurt, escaleer naar de grote klasse”, getoetst op je eigen set.

Spoor B. Met seed 7 krijg je:

bias 0.0: load [729, 1122, 1401, 1017, 803, 1216, 710, 1194]  CV²(importance)=0.155
bias 1.0: load [1489, 1024, 1338, 854, 678, 1116, 586, 1107]  CV²(importance)=0.163
bias 3.0: load [3113, 771, 1136, 611, 488, 861, 329, 883]  CV²(importance)=1.213

Bij bias 3 krijgt expert 1 3113 van de 8192 toewijzingen (38%); de belastingsmaat is dan bijna acht keer zo groot als zonder bias. Zonder tegenmaatregel in de training zou deze scheefstand zichzelf versterken.

Als het niet werkt, kijk naar …
  • 404 of “model not found”: de modelnaam in KLEIN/GROOT klopt niet (meer). Pak de actuele ID's uit de models overview.
  • Antwoord is leeg of afgekapt: bij modellen die denken tellen denk-tokens mee voor max_tokens. Verhoog max_tokens of controleer stop_reason.
  • Het label wordt niet herkend: het model antwoordt met een zin in plaats van één woord. Verscherp de prompt, of kijk of label in antw.lower() te streng of te los is.
  • Latency wisselt sterk: draai elke vraag een paar keer en neem de mediaan; één meting zegt weinig.
  • ModuleNotFoundError: numpy (spoor B): installeer numpy met pip install numpy, in een virtualenv.

Zelftoets