Conteúdo do curso Lição 186 de 250 · Padrões de Produção: Retries, Async, Streaming e Memória
Padrões de Produção: Retries, Async, Streaming e Memória

Tentar novamente com Backoff Exponencial

A primeira coisa que o mundo real ensina a um app de LLM é que as chamadas fail. Um limite de taxa, uma conexão perdida, um 503 do provedor -> nada disso significa que seu código está errado, significa que você deve esperar um momento e tentar de novo. O padrão padrão é retry with exponential backoff: em cada falha você espera mais tempo antes da próxima tentativa, então um soluço breve se recupera rápido enquanto um serviço com dificuldades não é sobrecarregado.

O atraso entre as tentativas dobra a cada vez. Se o atraso base é 0.5 segundos, você espera 0.5, depois 1.0, depois 2.0, e assim por diante -> a fórmula é base_delay * 2 ** attempt onde attempt é o número da tentativa baseado em zero. Após um número fixo de tentativas você desiste e deixa o erro propagar, porque tentar para sempre apenas esconde uma queda real.

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

Em produção a espera é uma time.sleep(delay) real, e em torno de um motor WebLLM on-device você envolveria o mesmo retry loop sobre engine.chat.completions.create(...). Mas dormir torna um teste lento e instável, então aqui você não dorme nada: você record os atrasos que você teria esperado e os retorna. Isso mantém tudo determinístico e testável instantaneamente, enquanto a lógica -> contar tentativas, calcular backoff, desistir no limite -> é exatamente o que vai para produção.

Um refinamento do mundo real para saber: dobrar o atraso sozinho faz com que cada cliente que falhou no mesmo momento tente novamente em sincronia, todos acordando juntos e sobrecarregando o serviço de novo (um "thundering herd"). Código de produção adiciona jitter -> uma pequena aleatoriedade para que as tentativas se espalhem, comumente dormindo uma quantidade aleatória até o atraso calculado ("full jitter", ex. time.sleep(random.uniform(0, delay))). Mantemos a função graduada determinística e registramos os valores exatos base_delay * 2 ** attempt; jitter é o refinamento de produção que você adicionaria por cima, não faz parte do exercício.

Construa retry_call(fn, max_attempts, base_delay). Chame fn(). Se ele retornar, entregue um dict {"value": result, "attempts": how_many_calls, "delays": [...]}. Se ele lançar, registre o backoff delay base_delay * 2 ** attempt (não use sleep) e tente novamente, até max_attempts chamadas totais. Se a tentativa final ainda lançar, deixe essa exceção propagar. Um callable que nunca falha é chamado exatamente uma vez com uma lista de delay vazia. Duas regras de clientes reais também pertencem aqui. Tente novamente apenas falhas transitórias (os status 408, 409, 429 e 5xx do módulo calling-llms); uma requisição malformada falha da mesma forma todas as vezes. E quando o servidor enviar um header retry-after, espere pelo menos esse tempo em vez do seu próprio backoff. O SDK oficial já faz ambos, duas vezes por padrão, então na prática você geralmente ajusta max_retries em vez de escrever este laço você mesmo.

Sua vez

Escreva retry_call(fn, max_attempts, base_delay, retryable=None) que chama fn() e tenta novamente quando ela ocorre, mas apenas erros que valem a tentativa: se retryable for fornecido (uma função da exceção para True/False) e retornar False, lance novamente de imediato sem outra tentativa. Com retryable=None, cada exceção conta como tentável. Ele e registra o atraso de backoff exponencial base_delay * 2 ** attempt antes de cada tentativa SEM dormir. Retorne {"value", "attempts", "delays"} em caso de sucesso; lance novamente uma vez que as chamadas max_attempts falharem todas. Uma fn que falha N-1 vezes e depois tem sucesso retorna o valor; os atrasos registrados iguais à referência exponencial; uma fn que nunca falha é chamada exatamente uma vez.

Viu um problema nesta lição? Reporte-o · Pergunte sobre esta lição

Este exercício abre em breve

Termine a lição anterior para que esta seja desbloqueada. O curso inteiro é gratuito, não precisa de conta, e você pode ler esta lição agora mesmo.