Python : 5 décorateurs essentiels pour booster les applications LLM

Optimiser les applications LLM avec Python

Les décorateurs Python sont des solutions sur mesure qui simplifient la gestion de la logique logicielle complexe, notamment dans les applications basées sur les modèles de langage (LLM). Ces modèles nécessitent souvent des interactions avec des API tierces, qui peuvent être imprévisibles, lentes et coûteuses. Les décorateurs permettent de rendre ces interactions plus efficaces en enveloppant les appels API avec une logique optimisée.

Mise en Cache en Mémoire

La bibliothèque standard functools de Python offre le décorateur lru_cache, qui est particulièrement utile pour les fonctions coûteuses impliquant des LLM. En enveloppant un appel API LLM dans un décorateur LRU (Least Recently Used), on ajoute un mécanisme de cache qui empêche les requêtes redondantes contenant des entrées identiques dans la même exécution ou session. Cela permet d'optimiser les problèmes de latence de manière élégante.

Voici un exemple illustrant 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é

Mise en Cache sur Disque Persistant

En matière de mise en cache, la bibliothèque externe diskcache va encore plus loin en implémentant un cache persistant sur disque, notamment via une base de données SQLite. Cela est particulièrement 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. Ce modèle de décorateur est à envisager 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.

Voici comment cela fonctionne :

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](/glossaire/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 !

Applications Résilientes au Réseau

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"))

Limitation de Débit Côté Client

Ce décorateur utilise la bibliothèque ratelimit pour contrôler la fréquence des appels à une fonction, généralement très demandée. Cela est 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}")

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.

Ces décorateurs Python sont essentiels pour optimiser les applications basées sur les LLM, en améliorant leur efficacité et leur fiabilité.