Als er iets misgaat · oefening
Begrens elke aanroep
De demonstratie van les 1 liet twee manieren zien waarop een aanroep kan doorlopen zonder nuttig einde: een antwoord dat te lang op zich laat wachten, en een antwoord dat langer doorgaat dan je wilt betalen. Een programma dat een model aanroept, hoort beide te begrenzen voordat het iets verstuurt. In deze les schrijf je call_once, één poging met beide grenzen, die elke latere functie in het hoofdstuk gebruikt.
Een grens aan de tijd
Hoofdstuk 5 gaf elke client één timeout-getal, CLIENT_TIMEOUT = 10.0 in client_calls.py. De client gebruikt het voor elke keer dat hij wacht: bij het openen van de verbinding, bij het versturen van het request en bij elke keer dat hij van de server leest. Duurt het wachten langer, dan geeft de client het op en werpt hij openai.APITimeoutError op, een soort openai.APIConnectionError.
Die grens zit al op elke client die de cursus bouwt, dus call_once stelt hem niet opnieuw in. Een aanroeper die voor één taak een andere grens nodig heeft, maakt met with_options een kopie van de client, zoals de demonstratie van deze les doet:
impatient = scenario_client("slow:1500").with_options(timeout=0.5)
slow:1500 laat het gescripte model 1.5 seconde wachten voordat het antwoordt. Met een time-out van 0.5 seconde stopt de client na ongeveer een halve seconde met wachten.
Een grens aan de lengte
max_tokens begrenst hoeveel tokens het antwoord mag hebben (hoofdstuk 2, les 4). Zonder die waarde beslist een aanbieder hoe lang een antwoord mag worden, en je betaalt voor elk token ervan. Vanaf nu bevat elk request dat dit hoofdstuk verstuurt max_tokens: de eigen waarde van het request als het die heeft, en anders DEFAULT_MAX_TOKENS, dat 800 is.
Het gescripte model accepteert max_tokens en negeert het, dus je ziet geen verschil in zijn antwoorden. pl-live verlaagt elke waarde boven 1000 naar 1000, en besteedt een deel van die limiet aan redeneren voordat het het zichtbare antwoord schrijft. 800 laat ruimte voor een quiz van meerdere vragen plus dat redeneren.
Een antwoord dat de limiet bereikt, stopt daar, met finish_reason "length". Les 5 behandelt dat.
Een request als dictionary
Vanaf deze les is een request één dictionary die een aanroep beschrijft. Die heeft altijd model en messages, en kan tools, response_format en max_tokens hebben:
question = {"model": MODEL, "messages": [{"role": "user", "content": "What is a Python list?"}]}
Een dictionary is makkelijk door te geven, ongewijzigd opnieuw te versturen en te controleren voordat hij wordt verstuurd, wat les 6 doet. call_once(request, *, client) maakt er één create-aanroep van:
client.chat.completions.create(
model=request["model"],
messages=request["messages"],
tools=request.get("tools", openai.omit),
response_format=request.get("response_format", openai.omit),
max_tokens=request.get("max_tokens", DEFAULT_MAX_TOKENS),
)
openai.omit is een speciale waarde uit het openai-pakket die “laat deze sleutel weg uit het request” betekent. Een request voor een gewoon antwoord heeft geen sleutel tools, dus request.get("tools", openai.omit) geeft openai.omit, en de body die de client verstuurt bevat helemaal geen tools. Als je in plaats daarvan None doorgeeft, wordt "tools": null verstuurd, en dat is niet hetzelfde als weglaten: het gescripte model accepteert het, maar andere diensten kunnen het afwijzen.
Elke sleutel wordt bij naam doorgegeven, dus wie call_once leest, ziet precies wat een request kan versturen. call_once geeft de response terug die create teruggaf, en vangt niets af: een fout uit create bereikt de aanroeper, en les 7 beslist wat ermee gebeurt.
Voer het uit
Voer python chapter9_demo.py uit als je call_once hebt geschreven:
One bounded call:
A list is an ordered, changeable collection of values. You write one with square brackets, like [1, 2, 3], and you can add, remove and change items after creating it.
The same call through a client that waits at most 0.5 seconds for a slow reply:
APITimeoutError: Request timed out.
Worth another attempt?
Run stopped at the next function to build: should_retry is built in Lesson 3.
De eerste aanroep is een gewoon antwoord. De tweede laat de tijdsgrens zien: de demonstratie vangt openai.APITimeoutError af en drukt de tekst ervan af, Request timed out., na ongeveer een halve seconde, een seconde voordat het gescripte model zou hebben geantwoord.
MODEL_SERVICE.md vertelt hoe je de body ziet die echt is verstuurd: last_request() in client_calls.py geeft die terug. Wil je het zelf zien, open dan de python en typ:
>>> from reliable import call_once
>>> from client_calls import MODEL, make_client, last_request
>>> response = call_once({"model": MODEL, "messages": [{"role": "user", "content": "What is a Python list?"}]}, client=make_client())
>>> "tools" in last_request()
False
Een request heeft geen sleutel tools. Waarom geeft call_once request.get("tools", openai.omit) door en niet request.get("tools")?
Eén taak mag hoogstens een halve seconde op een antwoord wachten. Waar komt die grens?
Opdracht
Schrijf in reliable.py call_once(request, *, client). Doe precies één client.chat.completions.create-aanroep met deze keywordargumenten, die je elk uit het request leest:
model=request["model"]enmessages=request["messages"]tools=request.get("tools", openai.omit)enresponse_format=request.get("response_format", openai.omit), zodat een request zonder die sleutels geen van beide verstuurtmax_tokens=request.get("max_tokens", DEFAULT_MAX_TOKENS), waarbij je de constante bij naam gebruikt
Geef de response terug. Verander de requestdictionary niet en vang geen fouten af: die moeten de aanroeper bereiken. Voer python chapter9_demo.py uit om een begrensde aanroep en een time-out te zien, en controleer daarna je werk.