Een LLM-aanroep is een HTTP-request · oefening
Tel wat een aanroep kostte
Elke aanroep van een echt model kost geld, en de response vertelt je hoeveel werk het was. Het laatste deel van het document dat je hebt gelezen, is usage:
"usage": {
"prompt_tokens": 6,
"completion_tokens": 42,
"total_tokens": 48
}
prompt_tokens telt wat het model las: elk bericht dat je stuurde. completion_tokens telt wat het schreef. total_tokens is die twee bij elkaar opgeteld.
Waar deze getallen vandaan komen
Een echt model telt met zijn eigen tokenizer, het opsplitsen dat je in les 2 zag. Het gescripte model schat alleen: het telt de tekens in je berichten, deelt door vier en rondt naar boven af. What is a Python list? is 22 tekens, en 22 gedeeld door 4 is 5.5, naar boven afgerond 6. Het antwoord van 166 tekens geeft 42. Een echt model zou voor dezelfde tekst andere getallen melden, dus zie de gescripte tellingen als vervanger voor het echte werk, niet als meting.
Prijzen gaan per miljoen tokens
Aanbieders publiceren twee prijzen per model: één voor invoertokens en één voor uitvoertokens, elk in dollars per miljoen tokens. Uitvoer kost bijna altijd meer. llm_basics.py heeft twee prijstabellen, met een datum in een commentaar erboven:
LIVE_PRICES = {"input_per_million": 0.03, "output_per_million": 0.13}
LARGER_MODEL_PRICES = {"input_per_million": 2.00, "output_per_million": 10.00}
LIVE_PRICES is wat het model achter pl-live kostte op OpenRouter toen deze les geschreven werd. LARGER_MODEL_PRICES is anthropic/claude-sonnet-5.5, een groot, bekend model uit dezelfde lijst, ter vergelijking. Prijzen veranderen, dus dit is een momentopname.
Om de prijs van een aanroep te berekenen, reken je elke kant apart uit en tel je ze op:
prompt_tokens = 6
completion_tokens = 42
input_cost = prompt_tokens * 0.03 / 1_000_000
output_cost = completion_tokens * 0.13 / 1_000_000
cost = input_cost + output_cost
print(f"${cost:.8f}")
Dat drukt $0.00000564 af. Zes invoertokens tegen drie cent per miljoen kosten $0.00000018, en 42 uitvoertokens tegen dertien cent per miljoen kosten $0.00000546. De underscores in 1_000_000 zijn er alleen om het getal leesbaar te maken; Python negeert ze.
De :.8f in de f-string toont het getal met acht decimalen. Zonder die toevoeging drukt Python heel kleine getallen af in wetenschappelijke notatie, zoals 5.64e-06, wat 5.64 miljoenste betekent.
Gebruik prompt_tokens en completion_tokens, nooit total_tokens. Het totaal gooit invoer en uitvoer op één hoop, en die hebben verschillende prijzen, dus geen enkele prijs maakt er de juiste kosten van.
Bouw call_cost
call_cost(usage, prices) krijgt een usage-dictionary zoals hierboven en een prijstabel met de sleutels input_per_million en output_per_million, en geeft de kosten in dollars terug als float. Haal de getallen uit de dictionaries in plaats van ze in de functie te schrijven, zodat dezelfde functie elke aanroep op elk model kan prijzen.
Voer python llm_basics.py uit als het werkt. De demonstratie berekent de prijs van de aanroep uit les 4 met beide prijstabellen, voor één keer en voor tienduizend keer:
At pl-live prices: $0.00000564 per call, $0.0564 for 10,000 calls
At the larger model's prices: $0.00043200 per call, $4.3200 for 10,000 calls
Dezelfde vraag kost op het grotere model ongeveer 77 keer meer. Voor één aanroep zijn beide piepklein. Voor een programma dat tienduizend vragen per dag beantwoordt, is de keuze van het model een echte beslissing, en daarom houden latere hoofdstukken een budget bij.
Een response meldt prompt_tokens 1000, completion_tokens 200 en total_tokens 1200. Waarom vermenigvuldig je 1200 niet met één prijs?
Opdracht
Vervang in llm_basics.py de onafgemaakte body van call_cost(usage, prices).
Geef de kosten van één aanroep in dollars terug als float: usage["prompt_tokens"] maal prices["input_per_million"], plus usage["completion_tokens"] maal prices["output_per_million"], waarbij je elk product deelt door een miljoen. Gebruik total_tokens niet.
Voer python llm_basics.py uit om de twee prijstabellen te vergelijken en controleer daarna je werk.