0%

Wenn etwas schiefgeht · Übung

Einen Stream nur erneut versuchen, bevor er etwas ausgibt

Eine Art von Aufruf liegt noch außerhalb von call_model: der Streaming-Chat. call_model gibt eine ganze Antwort zurück, aber chat_turn gibt die Antwort aus, während sie Stück für Stück ankommt. Das macht erneute Versuche schwieriger. Stehen schon zwei Sätze auf dem Bildschirm, wenn der Stream abbricht, würde ein erneuter Versuch eine neue Antwort beginnen, und ein Modell schreibt selten zweimal dieselbe Antwort. Die Person sähe die Hälfte einer Antwort, gefolgt von einer ganzen anderen.

Die Regel

Ein Stream wird nur erneut versucht, wenn noch nichts ausgegeben wurde. Damit bleiben zwei Fälle:

  • create selbst hat ausgelöst. Eine gestreamte Anfrage, die mit einem 429 oder 500 scheitert, scheitert, bevor ein Chunk ankommt, also wird ein Fehler von create, der einen erneuten Versuch lohnt, genauso erneut versucht wie in call_model.

  • Der Stream ist vor seinem ersten Textstück abgebrochen, und StreamBroken kam mit partial_text "" an. Es wurde nichts angezeigt, also ist ein erneuter Versuch sicher.

Ein StreamBroken, dessen partial_text nicht leer ist, wird ausgelöst, nie erneut versucht, und der Aufrufer entscheidet, was er der Person sagt.

Das vorgegebene stream_once

stream_once(request, *, client, budget) in reliable.py ist fertiger Code, der einen gestreamten Versuch macht. Lies ihn jetzt. Es ist stream_chat aus Kapitel 5 mit drei Änderungen:

  1. Es sendet max_tokens, request.get("max_tokens", DEFAULT_MAX_TOKENS), wie call_once, und es löst ReplyCutOff aus, wenn der Finish-Reason "length" ist.

  2. Es rechnet den Usage-Chunk dem Budget an. Eine gestreamte Antwort meldet ihre Tokens nur, weil die Anfrage mit stream_options={"include_usage": True} danach fragt; der letzte Chunk enthält dann usage, und stream_once addiert dessen total_tokens zu budget["used"]. Ein Stream, der abbricht, erreicht diesen Chunk nie, also werden seine Tokens hier nicht gezählt, obwohl ein Anbieter sie trotzdem berechnen würde.

  3. Wenn ein Stream vor seinem ersten Stück abbricht, gibt es nichts aus, nicht einmal einen Zeilenumbruch. Nach einem erneuten Versuch zeigt der Bildschirm also nur die Antwort, die geklappt hat.

Fehler aus create erreichen den Aufrufer unverändert, und ein abgebrochener Stream wird zu StreamBroken mit dem bisherigen Text, wie in Kapitel 5.

chat_turn

chat_turn(history, question, *, client, budget, sleep) baut die Nachrichten wie in Kapitel 5 und macht bis zu MAX_ATTEMPTS Versuche:

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

Für jeden Versuch von 1 bis MAX_ATTEMPTS:

  1. check_budget(request, budget).

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

  3. Bei StreamBroken: Wenn sein partial_text nicht "" ist oder dies der letzte Versuch war, löse ihn aus.

  4. Bei openai.APIError: Wenn should_retry(error) falsch ist oder dies der letzte Versuch war, löse ihn aus.

  5. Andernfalls warte wie call_model: Berechne wait_seconds(error, attempt), löse den Fehler aus, wenn die Wartezeit länger als MAX_WAIT ist, sonst sleep(wait) und versuch es erneut.

  6. Wenn ein Versuch erfolgreich ist, gib (reply, add_turn(messages[:-1], question, reply)) zurück, die Antwort und den neuen Verlauf, wie es chat_turn in Kapitel 5 getan hat.

Schritt 3 und 4 enden jeweils mit Schritt 5, also schreib das Warten in beide except-Blöcke. Es kann nicht einmal dahinter stehen: Python entfernt den Namen error, wenn sein except-Block endet.

Führe except StreamBroken und except openai.APIError als zwei getrennte Klauseln auf. StreamBroken ist kein openai-Fehler, also fängt keine der beiden Klauseln die Fehler der anderen ab. Ein StreamBroken hat keine Antwort, also verdoppelt wait_seconds dafür BASE_WAIT. ReplyCutOff wird nicht abgefangen: Ein abgeschnittener Stream hat seinen Text schon ausgegeben.

chat_turn gibt zwei Werte in einem Tupel zurück. Die Demonstration liest sie als result[0] und result[1].

Ausführen

Wenn chat_turn geschrieben ist, führe python chapter9_demo.py aus. Die Demonstration ruft reset_scripted_model() auf und fragt dann Explain Python lists in detail. über scenario_client("rate-limit:1") und danach über 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 '

Bei rate-limit:1 hat create einen RateLimitError ausgelöst, bevor ein Chunk ankam, also hat chat_turn die eine Sekunde aus Retry-After gewartet und es erneut versucht, und der zweite Stream hat die ganze Antwort einmal ausgegeben. Das Budget zählt diese Antwort, 229 Tokens mit der Systemnachricht für den Lern-Chat, weil stream_once nach dem Usage-Chunk gefragt hat. Der Verlauf enthält die Systemnachricht, die Frage und die Antwort.

Bei broken-stream standen die ersten Stücke schon auf dem Bildschirm, als die Verbindung geschlossen wurde, also hat chat_turn StreamBroken ohne zweiten Versuch ausgelöst.

Jeder Modellaufruf im Lernassistenten folgt jetzt diesen Regeln: call_model für das Quiz, den Agenten und jeden einzelnen Aufruf, und chat_turn für den Streaming-Chat, alle mit einem Budget.

Wann versucht chat_turn einen Stream erneut?

Warum hat chat_turn except StreamBroken und except openai.APIError als zwei getrennte Klauseln?

Aufgabe

Schreib in reliable.py die Funktion chat_turn(history, question, *, client, budget, sleep). Baue messages = prepare_messages(history, question) und request = {"model": MODEL, "messages": messages}. Für jeden Versuch von 1 bis MAX_ATTEMPTS:

  1. Ruf check_budget(request, budget) auf.

  2. Ruf innerhalb von try stream_once(request, client=client, budget=budget) auf.

  3. Bei StreamBroken: Löse ihn aus, wenn sein partial_text nicht "" ist oder dies der letzte Versuch war.

  4. Bei openai.APIError: Löse ihn aus, wenn should_retry(error) falsch ist oder dies der letzte Versuch war.

  5. Wenn du in einer dieser beiden Klauseln nicht ausgelöst hast, berechne wait_seconds(error, attempt), löse den Fehler aus, wenn die Wartezeit länger als MAX_WAIT ist, und ruf sonst sleep(wait) auf und versuch es erneut.

Wenn ein Versuch erfolgreich ist, gib (reply, add_turn(messages[:-1], question, reply)) zurück. Lass ReplyCutOff den Aufrufer erreichen. Ändere das vorgegebene stream_once nicht. Führe python chapter9_demo.py aus, um einen erneut versuchten und einen abgebrochenen Stream zu sehen, und prüfe dann deine Arbeit.