Programma Lezione 186 di 250 · Schemi di produzione: nuovi tentativi, async, streaming e memoria
Schemi di produzione: nuovi tentativi, async, streaming e memoria

Nuovi tentativi con backoff esponenziale

La prima cosa che il mondo reale insegna a un'app LLM è che le chiamate falliscono. Un limite di frequenza, una connessione caduta, un 503 dal fornitore -> niente di questo significa che il tuo codice è sbagliato, significa che dovresti aspettare un attimo e riprovare. Lo schema standard sono i nuovi tentativi con backoff esponenziale: a ogni fallimento aspetti di più prima del tentativo successivo, così un breve intoppo si risolve in fretta mentre un servizio in difficoltà non viene martellato.

L'attesa tra un tentativo e l'altro raddoppia ogni volta. Se l'attesa di base è 0.5 secondi, aspetti 0.5, poi 1.0, poi 2.0, e così via -> la formula è base_delay * 2 ** attempt dove attempt è il numero del nuovo tentativo contando da zero. Dopo un numero fisso di tentativi ti arrendi e lasci propagare l'errore, perché riprovare all'infinito nasconde solo un vero guasto.

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

In produzione l'attesa è un vero time.sleep(delay), e intorno a un motore WebLLM sul dispositivo avvolgeresti lo stesso ciclo di tentativi su engine.chat.completions.create(...). Ma dormire rende un test lento e ballerino, quindi qui non dormi affatto: registri le attese che avresti fatto e le restituisci. Così tutto resta deterministico e verificabile all'istante, mentre la logica -> contare i tentativi, calcolare il backoff, arrendersi al limite -> è esattamente quella che si rilascia.

Un perfezionamento del mondo reale da conoscere: raddoppiare soltanto l'attesa fa riprovare in sincronia tutti i client che sono falliti nello stesso momento, che si svegliano tutti insieme e travolgono di nuovo il servizio (una "mandria tonante", thundering herd). Il codice di produzione aggiunge il jitter -> un po' di casualità così i nuovi tentativi si sparpagliano, di solito dormendo una quantità casuale fino all'attesa calcolata ("full jitter", per esempio time.sleep(random.uniform(0, delay))). Teniamo deterministica la funzione valutata e registriamo i valori esatti base_delay * 2 ** attempt; il jitter è il perfezionamento di produzione che aggiungeresti sopra, non fa parte dell'esercizio.

Costruisci retry_call(fn, max_attempts, base_delay). Chiama fn(). Se restituisce un valore, restituisci un dict {"value": result, "attempts": how_many_calls, "delays": [...]}. Se solleva un errore, registra l'attesa di backoff base_delay * 2 ** attempt (non dormire) e riprova, fino a max_attempts chiamate in totale. Se anche l'ultimo tentativo solleva un errore, lascia propagare quell'eccezione. Una funzione chiamabile che non fallisce mai viene chiamata esattamente una volta con una lista di attese vuota. Anche due regole dei client veri stanno qui. Riprova solo i fallimenti passeggeri (gli stati 408, 409, 429 e 5xx del modulo calling-llms); una richiesta malformata fallisce allo stesso modo ogni volta. E quando il server manda un header retry-after, aspetta almeno quel tempo invece del tuo backoff. L'SDK ufficiale fa già entrambe le cose, due volte di default, quindi in pratica di solito regoli max_retries invece di scrivere tu questo ciclo.

Tocca a te

Scrivi retry_call(fn, max_attempts, base_delay, retryable=None) che chiama fn() e riprova quando solleva un errore, ma solo per gli errori che vale la pena riprovare: se retryable è dato (una funzione dall'eccezione a True/False) e restituisce False, rilancia subito senza un altro tentativo. Con retryable=None, ogni eccezione conta come da riprovare. Registra l'attesa di backoff esponenziale base_delay * 2 ** attempt prima di ogni nuovo tentativo SENZA dormire. Restituisci {"value", "attempts", "delays"} in caso di successo; rilancia una volta che tutte le max_attempts chiamate sono fallite. Una fn che fallisce N-1 volte e poi riesce restituisce il valore; le attese registrate sono uguali al riferimento esponenziale; una fn che non fallisce mai viene chiamata esattamente una volta.

Hai notato un problema in questa lezione? Segnalalo · Chiedi qualcosa su questa lezione

Questo esercizio si apre presto

Finisci la lezione precedente e questa si sblocca. L'intero corso è gratuito, senza account, e puoi leggere questa lezione subito.