5 Décorateurs Python Puissants pour Optimiser les Applications LLM

5 Décorateurs Python Puissants pour Optimiser les Applications LLM

Les décorateurs Python sont des solutions sur mesure conçues pour simplifier la logique logicielle complexe dans diverses applications, y compris celles basées sur les LLM. Travailler avec les LLM implique souvent de gérer des API tierces imprévisibles, lentes et souvent coûteuses. Les décorateurs peuvent rendre cette tâche plus propre en enveloppant, par exemple, les appels API avec une logique optimisée.

Examinons cinq décorateurs Python utiles qui vous aideront à optimiser vos applications basées sur les LLM sans charge supplémentaire notable. Les exemples fournis illustrent la syntaxe et l'approche d'utilisation de chaque décorateur. Ils sont parfois présentés sans utilisation réelle des LLM, mais ce sont des extraits de code destinés à faire partie d'applications plus larges.

1. Mise en Cache en Mémoire

Cette solution provient de la bibliothèque standard functools de Python et est utile pour les fonctions coûteuses comme celles utilisant des LLM. Si nous avions un appel API LLM dans la fonction définie ci-dessous, l'envelopper dans un décorateur LRU (Least Recently Used) ajoute un mécanisme de cache qui empêche les requêtes redondantes contenant des entrées identiques (prompts) dans la même exécution ou session. C'est une manière élégante d'optimiser les problèmes de latence.

Cet exemple illustre son utilisation :

from functools import lru_cache

@lru_cache(maxsize=100)
def summarize_text(text: str) -> str:
    print("Envoi du texte au LLM...")
    time.sleep(1)  # Simulation d'un délai réseau
    return f"Résumé de {len(text)} caractères."

print(summarize_text("Le rapide renard brun."))  # Prend une seconde
print(summarize_text("Le rapide renard brun."))  # Instantané

2. Mise en Cache sur Disque Persistant

En parlant de mise en cache, la bibliothèque externe diskcache va plus loin en implémentant un cache persistant sur disque, notamment via une base de données SQLite : très utile pour stocker les résultats de fonctions gourmandes en temps telles que les appels API LLM. De cette manière, les résultats peuvent être rapidement récupérés lors des appels ultérieurs si nécessaire. Envisagez d'utiliser ce modèle de décorateur lorsque la mise en cache en mémoire n'est pas suffisante, car l'exécution d'un script ou d'une application peut s'arrêter.

from diskcache import Cache

# Création d'un répertoire de base de données SQLite local léger
cache = Cache(".local_llm_cache")

@cache.memoize(expire=86400)  # Mis en cache pendant 24 heures
def fetch_llm_response(prompt: str) -> str:
    print("Appel de l'API LLM coûteuse...")  # Remplacez ceci par un appel API LLM réel
    time.sleep(2)  # Simulation de latence API
    return f"Réponse à : {prompt}"

print(fetch_llm_response("Qu'est-ce que l'informatique quantique ?"))  # 1er appel de fonction
print(fetch_llm_response("Qu'est-ce que l'informatique quantique ?"))  # Chargement instantané depuis le disque ici !

3. Applications Résilientes au Réseau

Étant donné que les LLM peuvent souvent échouer en raison d'erreurs transitoires ainsi que de délais d'attente et de réponses "502 Bad Gateway" sur Internet, l'utilisation d'une bibliothèque de résilience réseau comme tenacity avec le décorateur @retry peut aider à intercepter ces échecs réseau courants.

L'exemple ci-dessous illustre cette mise en œuvre d'un comportement résilient en simulant aléatoirement une chance de 70 % d'erreur réseau. Essayez plusieurs fois, et tôt ou tard, vous verrez cette erreur apparaître : totalement attendue et intentionnelle !

from tenacity import retry, wait_exponential, stop_after_attempt, retry_if_exception_type

class RateLimitError(Exception): pass

# Réessayer jusqu'à 4 fois, en attendant 2, 4 et 8 secondes entre chaque tentative
@retry(wait=wait_exponential(multiplier=2, min=2, max=10),
       stop=stop_after_attempt(4),
       retry=retry_if_exception_type(RateLimitError))
def call_flaky_llm_api(prompt: str):
    print("Tentative d'appel à l'API...")
    if random.random() < 0.7:  # Simulation d'une chance de 70 % d'échec de l'API
        raise RateLimitError("Limite de taux dépassée ! Rétrogradation.")
    return "Le texte a été généré avec succès !"

print(call_flaky_llm_api("Écris un haïku"))

4. Limitation de Débit Côté Client

Ce décorateur combiné utilise la bibliothèque ratelimit pour contrôler la fréquence des appels à une fonction (généralement très demandée) : utile pour éviter les limites côté client lors de l'utilisation d'API externes. L'exemple suivant le fait en définissant des limites de Demandes par Minute (RPM). Le fournisseur rejettera les prompts d'une application cliente lorsque trop de prompts simultanés sont lancés.

from ratelimit import limits, sleep_and_retry

# Application stricte d'une limite de 3 appels par fenêtre de 10 secondes
@sleep_and_retry
@limits(calls=3, period=10)
def generate_text(prompt: str) -> str:
    print(f"[{time.strftime('%X')}] Traitement : {prompt}")
    return f"Traité : {prompt}"

# Les 3 premiers s'affichent immédiatement, le 4ème fait une pause, respectant ainsi la limite
for i in range(5):
    generate_text(f"Prompt {i}")

5. Liaison de Sortie Structurée

Le cinquième décorateur de la liste utilise la bibliothèque magentic en conjonction avec Pydantic pour fournir un mécanisme d'interaction efficace avec les LLM via API, et obtenir des réponses structurées. Il simplifie le processus d'appel des API LLM. Ce processus est important pour inciter les LLM à renvoyer des données formatées comme des objets JSON de manière fiable. Le décorateur gérerait les prompts système sous-jacents et l'analyse dirigée par Pydantic, optimisant ainsi l'utilisation des tokens en conséquence et aidant à maintenir une charge de travail équilibrée.