Lehrplan Lektion 186 von 250 · Produktionsmuster: Retries, Async, Streaming & Memory
Produktionsmuster: Retries, Async, Streaming & Memory

Erneut versuchen mit exponentiellem Backoff

Das erste, was die reale Welt einer LLM App lehrt, ist dass Aufrufe fail. Ein Rate Limit, eine abgebrochene Verbindung, ein 503 vom Anbieter -> nichts davon bedeutet, dass dein Code falsch ist, sie bedeuten, dass du einen Moment warten und es erneut versuchen solltest. Das Standardmuster ist retry with exponential backoff: bei jedem Fehler wartest du länger vor dem nächsten Versuch, sodass ein kurzer Aussetzer schnell wieder funktioniert, während ein überlasteter Dienst nicht bombardiert wird.

Die Verzögerung zwischen den Wiederholungsversuchen verdoppelt sich jedes Mal. Wenn die Basisverzögerung 0.5 Sekunden beträgt, wartest du 0.5, dann 1.0, dann 2.0 und so weiter -> die Formel ist base_delay * 2 ** attempt wobei attempt die nullbasierte Nummer des Wiederholungsversuchs ist. Nach einer festen Anzahl von Versuchen gibst du auf und lässt den Fehler weiterlaufen, weil ewiges Wiederholen nur einen echten Ausfall verbirgt.

for attempt in range(max_attempts):
    try:
        return call_the_model()
    except Exception:
        # last attempt? re-raise. otherwise wait base_delay * 2**attempt
        ...

In der Produktion ist das Warten eine echte time.sleep(delay), und um eine On-Device WebLLM Engine würdest du dieselbe retry loop über engine.chat.completions.create(...) umschließen. Aber Schlafen macht einen Test langsam und instabil, also schläfst du hier gar nicht: du record die Verzögerungen, auf die du gewartet hättest, und gibst sie zurück. Das hält das Ganze deterministisch und sofort testbar, während die Logik -> Versuche zählen, Backoff berechnen, bei dem Limit aufgeben -> genau das ist, was ausgeliefert wird.

Eine echte Verfeinerung aus der Praxis: Die Verdopplung der Verzögerung allein sorgt dafür, dass jeder Client, der zum selben Zeitpunkt fehlgeschlagen ist, synchron neu versucht. Alle wachen gleichzeitig auf und überlasten den Dienst erneut (ein "thundering herd"). Produktionscode fügt jitter hinzu -> ein wenig Zufall, damit sich die Wiederholungen verteilen, meist durch Schlafen für eine zufällige Zeit bis zur berechneten Verzögerung ("full jitter", z. B. time.sleep(random.uniform(0, delay))). Wir halten die bewertete Funktion deterministisch und zeichnen die exakten base_delay * 2 ** attempt Werte auf; jitter ist die Produktionsverfeinerung, die du obenauf schichten würdest, aber nicht Teil der Übung.

Baue retry_call(fn, max_attempts, base_delay). auf. Rufe fn() auf. Wenn es zurückkehrt, gib ein dict {"value": result, "attempts": how_many_calls, "delays": [...]} zurück. Wenn es einen Fehler wirft, zeichne die backoff delay base_delay * 2 ** attempt auf (nicht schlafen) und versuche es erneut, bis zu max_attempts Gesamtaufrufen. Wenn der letzte Versuch immer noch einen Fehler wirft, lass diese Exception propagieren. Ein callable, der nie fehlschlägt, wird genau einmal mit einer leeren delay list aufgerufen. Zwei Regeln von echten Clients gehören auch hierhin. Wiederhole nur vorübergehende Fehler (die 408, 409, 429 und 5xx Status aus dem calling-llms Modul); eine falsch formatierte Anfrage schlägt jedes Mal auf die gleiche Weise fehl. Und wenn der Server einen retry-after Header sendet, warte mindestens so lange anstatt deines eigenen backoff. Das offizielle SDK macht beides bereits, standardmäßig zweimal, also passt du in der Praxis meistens max_retries an, anstatt diese Schleife selbst zu schreiben.

Du bist dran

Schreibe retry_call(fn, max_attempts, base_delay, retryable=None), das fn() aufruft und neu versucht, wenn es ausgelöst wird, aber nur Fehler, die einen neuen Versuch wert sind: wenn retryable gegeben ist (eine Funktion von der Exception zu True/False) und False zurückgibt, löse sie sofort neu aus ohne weiteren Versuch. Mit retryable=None zählt jede Exception als neu versuchbar. Es und zeichnet die exponentielle Backoff Verzögerung base_delay * 2 ** attempt vor jedem neuen Versuch OHNE zu schlafen auf. Gib {"value", "attempts", "delays"} bei Erfolg zurück; löse neu aus, sobald alle max_attempts Aufrufe fehlgeschlagen sind. Eine fn, die N-1 Mal fehlschlägt und dann erfolgreich ist, gibt den Wert zurück; die aufgezeichneten Verzögerungen entsprechen der exponentiellen Referenz; eine nie fehlschlagende fn wird genau einmal aufgerufen.

Ein Problem in dieser Lektion entdeckt? Melde es · Frage zu dieser Lektion

Diese Übung öffnet bald

Beende die vorherige Lektion, damit diese freigeschaltet wird. Der ganze Kurs ist kostenlos, kein Konto erforderlich, und du kannst diese Lektion jetzt direkt lesen.