Programme Leçon 186 sur 250 · Schémas de production : nouvelles tentatives, async, streaming et mémoire
Schémas de production : nouvelles tentatives, async, streaming et mémoire

Réessayer avec un délai exponentiel

La première chose que le monde réel apprend à une appli LLM, c'est que les appels échouent. Une limite de débit, une connexion coupée, un 503 du fournisseur -> rien de tout ça ne veut dire que ton code est faux, ça veut dire qu'il faut attendre un peu et réessayer. Le schéma standard est la nouvelle tentative avec délai exponentiel (retry with exponential backoff) : à chaque échec, tu attends plus longtemps avant la tentative suivante, donc un petit raté se rattrape vite tandis qu'un service en difficulté n'est pas martelé.

Le délai entre les tentatives double à chaque fois. Si le délai de base vaut 0.5 seconde, tu attends 0.5, puis 1.0, puis 2.0, et ainsi de suite -> la formule est base_delay * 2 ** attempt où attempt est le numéro de la tentative en partant de zéro. Après un nombre fixe de tentatives, tu abandonnes et laisses l'erreur remonter, car réessayer à l'infini ne fait que cacher une vraie panne.

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

En production, l'attente est un vrai time.sleep(delay), et autour d'un moteur WebLLM sur l'appareil tu envelopperais la même boucle autour de engine.chat.completions.create(...). Mais dormir rend un test lent et instable, donc ici tu ne dors pas du tout : tu notes les délais que tu aurais attendus et tu les renvoies. Ça garde le tout déterministe et testable instantanément, tandis que la logique -> compter les tentatives, calculer le délai, abandonner à la limite -> est exactement celle qu'on livre.

Un raffinement concret à connaître : doubler seulement le délai fait réessayer au même rythme tous les clients qui ont échoué au même moment, qui se réveillent tous ensemble et frappent à nouveau le service (une « ruée »). Le code de production ajoute du jitter -> un peu de hasard pour étaler les tentatives, souvent en dormant une durée aléatoire jusqu'au délai calculé (« full jitter », par ex. time.sleep(random.uniform(0, delay))). On garde la fonction notée déterministe et on note les valeurs exactes de base_delay * 2 ** attempt ; le jitter est le raffinement de production que tu ajouterais par-dessus, il ne fait pas partie de l'exercice.

Construis retry_call(fn, max_attempts, base_delay). Appelle fn(). Si elle renvoie une valeur, rends un dict {"value": result, "attempts": how_many_calls, "delays": [...]}. Si elle lève une exception, note le délai base_delay * 2 ** attempt (sans dormir) et réessaie, jusqu'à max_attempts appels au total. Si la dernière tentative lève encore une exception, laisse-la remonter. Une fonction qui n'échoue jamais est appelée exactement une fois, avec une liste de délais vide. Deux règles des vrais clients ont aussi leur place ici. Ne réessaie que les échecs passagers (les statuts 408, 409, 429 et 5xx du module calling-llms) ; une requête mal formée échoue de la même façon à chaque fois. Et quand le serveur envoie un en-tête retry-after, attends au moins cette durée au lieu de ton propre délai. Le SDK officiel fait déjà les deux, deux fois par défaut, donc en pratique tu règles en général max_retries au lieu d'écrire cette boucle toi-même.

À ton tour

Écris retry_call(fn, max_attempts, base_delay, retryable=None) qui appelle fn() et réessaie quand elle lève une exception, mais seulement pour les erreurs qui valent la peine : si retryable est fourni (une fonction qui prend l'exception et renvoie True/False) et renvoie False, relève l'exception tout de suite sans nouvelle tentative. Avec retryable=None, toute exception compte comme réessayable. Elle note aussi le délai exponentiel base_delay * 2 ** attempt avant chaque nouvelle tentative, SANS dormir. Renvoie {"value", "attempts", "delays"} en cas de succès ; relève l'exception une fois que les max_attempts appels ont tous échoué. Une fn qui échoue N-1 fois puis réussit renvoie la valeur ; les délais notés correspondent à la référence exponentielle ; une fn qui n'échoue jamais est appelée exactement une fois.

Tu as repéré un problème dans cette leçon ? Signale-le · Pose une question sur cette leçon

Cet exercice s'ouvre bientôt

Termine la leçon précédente pour débloquer celle-ci. Tout le cours est gratuit, aucun compte n'est requis, et tu peux lire cette leçon dès maintenant.