0%

Gesprekken en instructies

Het contextvenster en max_tokens

Je gesprek groeit nu elke beurt met twee berichten, en alles wordt bij elke aanroep meegestuurd. Dat heeft twee gevolgen waar je rekening mee moet houden: een grens aan hoeveel een model kan lezen, en een rekening die met elke beurt groeit.

Het contextvenster

Een model kan in één aanroep maar met een beperkt aantal tokens werken. Die grens is zijn contextvenster (context window). Alles in het request telt mee: het systeembericht, elk eerder gebruikers- en assistant-bericht en de nieuwe vraag. Bij de meeste modellen telt het antwoord dat het model schrijft ook mee voor dezelfde grens.

Contextvensters verschillen sterk per model, en ze zijn in de loop der jaren gegroeid. Ze lopen van tienduizenden tokens tot een miljoen of meer, afhankelijk van het model, dus zoek het getal op voor het model dat je gebruikt. Zelfs de onderkant klinkt als ruim genoeg voor een chat. Dat is het niet meer als een gesprek lang doorloopt, of als elk bericht een geplakt document bevat, zoals bij jou in hoofdstuk 8.

Als een request niet past, krijg je geen antwoord dat stilletjes de oudste berichten negeert. Wat er gebeurt, hangt af van de aanbieder: meestal mislukt het request met een foutmelding, en sommige diensten knippen zelf een deel van het gesprek weg, zonder te vragen welk deel ertoe doet. Hoe dan ook is je programma de juiste plek om te beslissen wat je bewaart. Les 5 doet dat.

Elke beurt betaalt opnieuw voor de hele geschiedenis

In hoofdstuk 1 berekende je de prijs van een aanroep uit zijn usage: invoertokens tegen de ene prijs, uitvoertokens tegen een andere. In een gesprek bevat de invoer van elke aanroep de hele geschiedenis tot dan toe, dus elke beurt leest, en betaalt voor, alles daarvoor opnieuw. Sommige aanbieders geven korting op invoer die ze kort geleden al zagen, prompt caching genoemd, maar je stuurt nog steeds elke keer de hele geschiedenis, en deze cursus rekent elk invoertoken tegen het volle tarief.

Hier is een uitgewerkt voorbeeld met ronde getallen. Stel dat het systeembericht 90 tokens is, elke vraag 10 tokens en elk antwoord 90 tokens. Beurt 1 stuurt het systeembericht en één vraag. Elke latere beurt stuurt ook elke eerdere vraag en elk eerder antwoord, 100 tokens meer per beurt:

BeurtInvoertokensUitvoertokensKosten tegen pl-live-prijzenKosten tegen de prijzen van het grotere model
110090$0.0000147$0.0011
220090$0.0000177$0.0013
550090$0.0000267$0.0019
10100090$0.0000417$0.0029

De kosten komen uit de prijstabellen van hoofdstuk 1: $0.03 per miljoen invoertokens en $0.13 per miljoen uitvoertokens voor pl-live, en $2.00 en $10.00 voor het grotere model. Beurt 10 tegen pl-live-prijzen is 1000 × 0.03 / 1000000 + 90 × 0.13 / 1000000 dollar.

Beurt 10 stuurt tien keer zoveel invoertokens als beurt 1. Tegen pl-live-prijzen kost hij ongeveer 2.8 keer zoveel als beurt 1, niet tien keer, omdat het antwoord, dat als uitvoer wordt geprijsd, even groot blijft. Het invoerdeel van de kosten groeit met elke beurt, en over het hele gesprek van tien beurten sturen de aanroepen 5500 invoertokens, waar tien losse aanroepen, elk met het systeembericht en één vraag, er 1000 zouden sturen.

Een lang gesprek wordt ook trager. Voordat een model het eerste woord van zijn antwoord schrijft, moet het het hele request lezen, dus bij een langer request duurt het langer voordat het antwoord begint.

max_tokens begrenst het antwoord

Je kunt een maximum zetten op hoe lang het antwoord mag zijn met max_tokens in de body van het request:

body = {
    "model": "pl-scripted",
    "messages": [{"role": "user", "content": "Explain decorators."}],
    "max_tokens": 200,
}
print(body["max_tokens"])

max_tokens begrenst alleen wat het model schrijft. Het doet niets aan de geschiedenis die je stuurt. Als het model het maximum bereikt, stopt het waar het is en heeft de response finish_reason "length", die je in hoofdstuk 1, les 5 tegenkwam. Het antwoord is dan midden in afgekapt, en bij een model dat nadenkt voordat het antwoordt kan het zelfs leeg zijn. Een maximum beschermt dus je budget, maar een te laag maximum geeft je kapotte antwoorden.

Het live model respecteert max_tokens. Het gescripte model accepteert het en negeert het, dus je requests aan pl-scripted blijven werken of je het nu meestuurt of niet. SCRIPTED_MODEL.md zegt dat ook.

Wat groeit er bij elke nieuwe beurt in een gesprek dat elke keer de hele geschiedenis meestuurt?

Je zet "max_tokens": 50 in een request aan het live model. Wat begrenst dat?

Een studiechat loopt al een uur. Waarom is elk nieuw antwoord trager en duurder dan het eerste was?