0%

Hoofdstuk 9

Als er iets misgaat

Wat er mis kan gaan bij een modelaanroep

Elke functie die de studieassistent tot nu toe heeft, roept het model aan en hoopt er het beste van. Als de dienst druk of traag is, of het request niet accepteert, reist de fout omhoog door je code en stopt het programma. Dat was de juiste keuze zolang je leerde hoe een aanroep eruitziet, en hoofdstuk 5 zette het automatisch opnieuw proberen (retries) van de client zelf uit, zodat je elke fout zou zien. Dit hoofdstuk beslist wat je met elk ervan doet.

Een modelaanroep kan op meer manieren mislukken dan de meeste functieaanroepen. De dienst kan overbelast zijn, een antwoord kan te lang duren, het request kan fout zijn, het antwoord kan halverwege stoppen, en een programma dat in een lus draait, zoals de agent uit hoofdstuk 7, kan meer tokens uitgeven dan iemand bedoelde. Sommige daarvan gaan vanzelf over als je wacht en het opnieuw probeert. Andere nooit, en dan kost opnieuw proberen alleen tijd en geld.

Je project voor dit hoofdstuk

Open reliable.py in de projecteditor. Onder time, openai en de ValidationError van pydantic importeert het uit de cursusbestanden die je in eerdere hoofdstukken hebt gebouwd. agent.py is de afgeronde agent uit hoofdstuk 7, retrieval.py en answer_models.py zijn het afgeronde ophalen (retrieval) uit hoofdstuk 8, en de bestanden die zij importeren staan er zoals eerder naast. Je hoeft geen van die bestanden te veranderen. De controle van je werk gebruikt eigen kopieën, dus een wijziging daarin kan geen beoordeling veranderen, maar wel de demonstratie laten vastlopen.

errors.py bevat nu drie meegeleverde foutklassen: StreamBroken uit hoofdstuk 3, en twee nieuwe die je in les 5 en 6 tegenkomt, ReplyCutOff en BudgetExceeded.

Bovenaan reliable.py staan vier getallen die het hoofdstuk gebruikt: DEFAULT_MAX_TOKENS = 800, BASE_WAIT = 1, MAX_WAIT = 60 en MAX_ATTEMPTS = 3. Daaronder staat QUIZ_FORMAT, dat les 8 gebruikt, en dan de functies. Twee zijn afgeronde code: stream_once, dat je in les 9 leest, en sleep_and_say, dat de demonstratie vanaf les 7 gebruikt. Tien zijn nog niet af, en één, run_agent, begint als de afgeronde lus uit hoofdstuk 7, die les 8 aanpast.

In dit hoofdstuk voer je python chapter9_demo.py uit, niet reliable.py. chapter9_demo.py is een meegeleverde demonstratie die je functies uit reliable.py importeert en elk ervan aanroept zodra die bestaat, met eigen afgeronde hulpfuncties: show_failures, retry_demo en budget_demo. Je hoeft het niet te veranderen. Je werk komt in reliable.py, en bij de controle van je werk wordt de demonstratie niet uitgevoerd.

Zeven manieren om te mislukken

Voer nu in de Shell python chapter9_demo.py uit, voordat je iets verandert. De demonstratie roept show_failures() aan, dat zeven keer What is a Python list? verstuurt. Vijf keer gebruikt het een client uit scenario_client, die het gescripte model met opzet op een gekozen manier laat mislukken (MODEL_SERVICE.md noemt elk scenario). Eén keer vraagt het om een model dat niet bestaat, en één keer verstuurt het een request zonder berichten. Voor elk geval drukt het de klassenaam van de fout af en, als de fout met een HTTP-status kwam, de status_code:

One question under each failure:
rate-limit: RateLimitError 429
server-error: InternalServerError 500
gateway-timeout:300: InternalServerError 504
slow:1500, timeout=0.5: APITimeoutError
length: finish_reason length
model pl-unknown: NotFoundError 404
no messages: BadRequestError 400
One bounded call:
Run stopped at the next function to build: call_once is built in Lesson 2.

Dit betekent elke regel:

  • RateLimitError 429 is “te veel requests”. De dienst is in orde, maar neemt op dit moment niets meer van je aan. Het antwoord bevat een Retry-After-header die zegt hoeveel seconden je moet wachten, hier 1.

  • InternalServerError 500 betekent dat er aan de kant van de dienst iets misging. Je request was misschien prima.

  • InternalServerError 504 is een gateway-time-out: een server vóór het model gaf het wachten erop op. De openai-client werpt InternalServerError op voor elke status vanaf 500, dus 502 en 503 komen op dezelfde manier binnen.

  • APITimeoutError kwam van je eigen kant. De client voor die regel wacht hoogstens 0.5 seconde, en slow:1500 doet 1.5 seconde over een antwoord, dus de client gaf het op. Er is geen status, want er kwam geen antwoord.

  • finish_reason length is helemaal geen fout. De aanroep is gelukt, maar het antwoord stopte bij zijn tokenlimiet, dus het is onvolledig. Er werd niets opgeworpen, en juist daardoor mis je het makkelijk.

  • NotFoundError 404 betekent dat de dienst geen model heeft dat pl-unknown heet.

  • BadRequestError 400 betekent dat de dienst het request zelf afwees, hier omdat messages leeg was.

Twee andere fouten zie je niet in deze uitvoer. Een 403, PermissionDeniedError, is wat pl-live antwoordt als je account geen live toegang heeft. En een verbinding kan mislukken voordat er een antwoord is, wat APIConnectionError opwerpt; APITimeoutError is een soort APIConnectionError.

Drie groepen

Waar het om gaat is niet de klassenaam, maar wat je programma daarna moet doen. Elke fout valt in een van drie groepen.

Opnieuw proberen na een wachttijd

Het request was in orde en het probleem gaat waarschijnlijk over: een 429, elke 5xx, een time-out, of een verbinding die mislukte voordat er een antwoord binnenkwam. Even wachten en hetzelfde request opnieuw versturen werkt vaak.

Het request verbeteren

Hetzelfde request mislukt elke keer op dezelfde manier: een 400, een 404 of een afgekapt antwoord. Een afgekapt antwoord heeft een hogere max_tokens of een korter request nodig. Een 400 of 404 opnieuw proberen mislukt alleen weer, en kost tijd en een request van je rate limit. Een afgekapt antwoord opnieuw proberen is erger: het model schrijft het nog een keer, en je betaalt nog een keer voor die tokens.

Opgeven en melden

Sommige fouten zijn voor dit programma definitief, dus de juiste zet is stoppen en zeggen wat er gebeurde:

  • een 403: geen live toegang, en wachten verandert dat niet;

  • een weigering, waarbij het model niet wilde antwoorden; dat is zijn antwoord en geen mislukte aanroep;

  • uitvoer die nog steeds ongeldig is na de ene corrigerende nieuwe poging uit hoofdstuk 4;

  • een 429 waarvan de Retry-After vraagt om veel later terug te komen dan MAX_WAIT, dat 60 seconden is.

Die laatste verdient een nadere blik, want dezelfde status kan bij twee groepen horen. pl-live heeft twee limieten. Als je over de limiet per minuut gaat, is de Retry-After het aantal seconden tot de volgende minuut begint, tussen 1 en 60, dus wachten loont en het programma probeert het opnieuw. Als je over de daglimiet gaat, is de Retry-After het aantal seconden tot 00:00 UTC, en dat kunnen vele uren zijn. Geen programma hoort midden in een aanroep zo lang te slapen, dus het geeft op en meldt het.

Een stream die halverwege breekt, werpt ook APIConnectionError op. Dat lijkt op de eerste groep, maar als een deel van het antwoord al op het scherm staat, zou een nieuwe poging een tweede, ander antwoord na het eerste afdrukken. Les 9 legt uit waarom een stream alleen opnieuw wordt geprobeerd voordat er tekst is getoond.

Het plan voor dit hoofdstuk

Les 2 begrenst elke aanroep, in tijd en in de lengte van het antwoord. Les 3 beslist welke fouten een nieuwe poging waard zijn, en les 4 beslist hoe lang je daarvoor wacht. Les 5 vangt een afgekapt antwoord af, en les 6 geeft het programma een eigen tokenbudget dat een aanroep weigert voordat die wordt verstuurd. Het project, les 7, voegt deze onderdelen samen in één functie, call_model. Les 8 en 9 leiden de quiz, de agent en de streamende chat erdoorheen, zodat de hele studieassistent één set regels volgt.

Een programma krijgt vier fouten: een 429 met Retry-After: 2, een 400 voor een verkeerd gespeld veld, een 503, en een 429 met Retry-After: 30000. Welke moet het na een wachttijd opnieuw proberen?

Waarom heeft het geen zin om een 400 Bad Request opnieuw te proberen?

Een gestreamd antwoord heeft twee zinnen afgedrukt als de verbinding wegvalt en de client APIConnectionError opwerpt. Waarom probeert de cursus het niet gewoon opnieuw?