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:
createzelf wierp een fout op. Een gestreamd request dat mislukt met een429of een500, mislukt voordat er een stukje (chunk) binnenkomt, dus een fout uitcreatedie een nieuwe poging waard is, wordt opnieuw geprobeerd zoalscall_modeldat doet.De stream brak vóór zijn eerste tekstdeel, en
StreamBrokenkwam binnen metpartial_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:
Hij verstuurt
max_tokens,request.get("max_tokens", DEFAULT_MAX_TOKENS), net alscall_once, en hij werptReplyCutOffop als de finish reason"length"is.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 danusage, enstream_oncetelt detotal_tokensdaarvan op bijbudget["used"]. Een stream die breekt, bereikt dat stukje nooit, dus de tokens ervan worden hier niet geteld, hoewel een aanbieder ze wel zou afrekenen.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:
check_budget(request, budget).Binnen
try:reply = stream_once(request, client=client, budget=budget).Bij
StreamBroken: als departial_textervan niet""is, of dit de laatste poging was, werp je hem op.Bij
openai.APIError: alsshould_retry(error)onwaar is, of dit de laatste poging was, werp je hem op.Wacht anders zoals
call_modeldat doet: berekenwait_seconds(error, attempt), werp de fout op als de wachttijd langer is danMAX_WAIT, en roep anderssleep(wait)aan en probeer het opnieuw.Als een poging lukt, geef je
(reply, add_turn(messages[:-1], question, reply))terug, het antwoord en de nieuwe geschiedenis, zoalschat_turnuit 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:
Roep
check_budget(request, budget)aan.Roep binnen
trystream_once(request, client=client, budget=budget)aan.Werp bij
StreamBrokende fout op als departial_textervan niet""is of dit de laatste poging was.Werp bij
openai.APIErrorde fout op alsshould_retry(error)onwaar is of dit de laatste poging was.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 danMAX_WAIT, en roep je anderssleep(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.