0%

Als er iets misgaat · oefening

Probeer een stream alleen opnieuw voordat hij iets afdrukt

Eén soort aanroep valt nog buiten call_model: de streamende chat. call_model geeft een hele response terug, maar chat_turn drukt het antwoord af terwijl het binnenkomt, stukje voor stukje. Dat maakt opnieuw proberen lastiger. Als er al twee zinnen op het scherm staan wanneer de stream breekt, zou een nieuwe poging een nieuw antwoord beginnen, en een model schrijft zelden twee keer hetzelfde antwoord. De persoon zou de helft van het ene antwoord zien, gevolgd door het hele andere.

De regel

Een stream wordt alleen opnieuw geprobeerd als er nog niets is afgedrukt. Dat laat twee gevallen over:

  • create zelf wierp een fout op. Een gestreamd request dat mislukt met een 429 of een 500, mislukt voordat er een stukje (chunk) binnenkomt, dus een fout uit create die een nieuwe poging waard is, wordt opnieuw geprobeerd zoals call_model dat doet.

  • De stream brak vóór zijn eerste tekstdeel, en StreamBroken kwam binnen met partial_text "". Er was niets getoond, dus een nieuwe poging is veilig.

Een StreamBroken waarvan partial_text niet leeg is, wordt opgeworpen en nooit opnieuw geprobeerd, en de aanroeper beslist wat hij de persoon vertelt.

De meegeleverde stream_once

stream_once(request, *, client, budget) in reliable.py is afgeronde code die één gestreamde poging doet. Lees het nu. Hij is stream_chat uit hoofdstuk 5 met drie wijzigingen:

  1. Hij verstuurt max_tokens, request.get("max_tokens", DEFAULT_MAX_TOKENS), net als call_once, en hij werpt ReplyCutOff op als de finish reason "length" is.

  2. Hij telt het usage-stukje op bij het budget. Een gestreamd antwoord meldt zijn tokens alleen omdat het request erom vraagt met stream_options={"include_usage": True}; het laatste stukje bevat dan usage, en stream_once telt de total_tokens daarvan op bij budget["used"]. Een stream die breekt, bereikt dat stukje nooit, dus de tokens ervan worden hier niet geteld, hoewel een aanbieder ze wel zou afrekenen.

  3. Als een stream breekt vóór zijn eerste tekstdeel, drukt hij niets af, zelfs geen newline. Na een nieuwe poging toont het scherm dus alleen het antwoord dat werkte.

Fouten uit create bereiken de aanroeper ongewijzigd, en een gebroken stream wordt StreamBroken met de tekst tot dan toe, zoals in hoofdstuk 5.

chat_turn

chat_turn(history, question, *, client, budget, sleep) bouwt de berichten zoals hoofdstuk 5 deed en doet tot MAX_ATTEMPTS pogingen:

messages = prepare_messages(history, question)
request = {"model": MODEL, "messages": messages}

Voor elke poging van 1 tot en met MAX_ATTEMPTS:

  1. check_budget(request, budget).

  2. Binnen try: reply = stream_once(request, client=client, budget=budget).

  3. Bij StreamBroken: als de partial_text ervan niet "" is, of dit de laatste poging was, werp je hem op.

  4. Bij openai.APIError: als should_retry(error) onwaar is, of dit de laatste poging was, werp je hem op.

  5. Wacht anders zoals call_model dat doet: bereken wait_seconds(error, attempt), werp de fout op als de wachttijd langer is dan MAX_WAIT, en roep anders sleep(wait) aan en probeer het opnieuw.

  6. Als een poging lukt, geef je (reply, add_turn(messages[:-1], question, reply)) terug, het antwoord en de nieuwe geschiedenis, zoals chat_turn uit hoofdstuk 5 deed.

Stap 3 en 4 eindigen allebei met stap 5, dus schrijf het wachten in beide except-blokken. Het kan niet één keer erna: Python verwijdert de naam error als het bijbehorende except-blok eindigt.

Zet except StreamBroken en except openai.APIError neer als twee aparte clausules. StreamBroken is geen openai-fout, dus geen van beide clausules vangt de fouten van de andere af. Een StreamBroken heeft geen response, dus wait_seconds verdubbelt er BASE_WAIT voor. ReplyCutOff wordt niet afgevangen: een afgekapte stream heeft zijn tekst al afgedrukt.

chat_turn geeft twee waarden terug in een tuple. De demonstratie leest ze als result[0] en result[1].

Voer het uit

Voer python chapter9_demo.py uit als je chat_turn hebt geschreven. De demonstratie roept reset_scripted_model() aan en vraagt dan Explain Python lists in detail., eerst via scenario_client("rate-limit:1") en daarna via scenario_client("broken-stream"):

The study chat under rate-limit:1:
  (waiting 1.0 s)
A list is an ordered collection that can hold any mix of values. You create one with square brackets, such as scores = [90, 72, 85]. Each item has a position, starting at 0, so scores[0] is 90 and scores[-1] is the last item. Slicing takes a range: scores[0:2] gives a new list with the first two items. Lists are mutable, which means you can change them after creating them: scores.append(60) adds an item to the end, scores.remove(72) removes the first matching value, and scores[1] = 75 replaces an item in place. Because a list is changed in place, two names that refer to the same list both see the change. Use list.copy() when you need an independent list. len(scores) tells you how many items it holds.
The history now holds 3 messages. Budget: {'limit': 20000, 'used': 229}
The study chat under broken-stream:
A list is an ordered collection that can hold 
StreamBroken. The partial text was 'A list is an ordered collection that can hold '

Onder rate-limit:1 wierp create een RateLimitError op voordat er een stukje binnenkwam, dus chat_turn wachtte de ene seconde uit Retry-After en probeerde het opnieuw, en de tweede stream drukte het hele antwoord één keer af. Het budget telt dat antwoord, 229 tokens met het systeembericht voor studeren, omdat stream_once om het usage-stukje vroeg. De geschiedenis bevat het systeembericht, de vraag en het antwoord.

Onder broken-stream stonden de eerste stukjes al op het scherm toen de verbinding werd gesloten, dus chat_turn wierp StreamBroken op zonder tweede poging.

Elke modelaanroep in de studieassistent volgt nu deze regels: call_model voor de quiz, de agent en elke losse aanroep, en chat_turn voor de streamende chat, allemaal met één budget.

Wanneer probeert chat_turn een stream opnieuw?

Waarom heeft chat_turn except StreamBroken en except openai.APIError als twee aparte clausules?

Opdracht

Schrijf in reliable.py chat_turn(history, question, *, client, budget, sleep). Bouw messages = prepare_messages(history, question) en request = {"model": MODEL, "messages": messages}. Voor elke poging van 1 tot en met MAX_ATTEMPTS:

  1. Roep check_budget(request, budget) aan.

  2. Roep binnen try stream_once(request, client=client, budget=budget) aan.

  3. Werp bij StreamBroken de fout op als de partial_text ervan niet "" is of dit de laatste poging was.

  4. Werp bij openai.APIError de fout op als should_retry(error) onwaar is of dit de laatste poging was.

  5. Als je in een van die twee clausules niet hebt opgeworpen, bereken je wait_seconds(error, attempt), werp je de fout op als de wachttijd langer is dan MAX_WAIT, en roep je anders sleep(wait) aan en probeer je het opnieuw.

Geef bij een geslaagde poging (reply, add_turn(messages[:-1], question, reply)) terug. Laat ReplyCutOff de aanroeper bereiken. Verander de meegeleverde stream_once niet. Voer python chapter9_demo.py uit om een opnieuw geprobeerde stream en een gebroken stream te zien, en controleer daarna je werk.