Parcourir les aide-mémoire · Ingénierie IA pour les données

Technologie: Ingénierie IA pour les donnéesCatégorie: Optimisation des tokensNiveau: IntermédiaireMis à jour

Optimiser les tokens d’un LLM

Réduisez la consommation de tokens d’un LLM dans vos applications de données sans perdre le contexte ni la qualité utiles : mesurer d’abord, alléger prompts et historique, limiter la récupération, compacter les sorties, mettre en cache et router.

Sur cette page
  1. Problème
  2. Réponse rapide
  3. Notions de base sur les tokens
  4. Tokens d’entrée et de sortie
  5. Pourquoi le contexte répété coûte cher
  6. Code / commandes
  7. 1. Mesurer avant d’optimiser
  8. 2. Raccourcir et dédoublonner les instructions
  9. 3. Garder stables les instructions stables
  10. 4. Résumer ou tronquer l’historique de conversation
  11. 5. Limiter le contexte récupéré
  12. 6. Découper seulement quand c’est utile
  13. 7. Envoyer le schéma utile, pas tout le catalogue
  14. 8. Demander des formats de sortie concis
  15. 9. Sortie structurée ou prose verbeuse
  16. 10. Mettre en cache le contexte stable et les résultats
  17. 11. Router les tâches vers le bon modèle, ou vers aucun
  18. 12. Regrouper les petits éléments quand la tâche le permet
  19. Tableau de décision des techniques
  20. Points à vérifier
  21. Erreurs fréquentes
  22. 1. Optimiser sans référence
  23. 2. Utiliser le plafond de tokens de sortie pour raccourcir les réponses
  24. 3. Faire disparaître les identifiants dans les résumés
  25. 4. Récupérer un top-20 « au cas où »
  26. 5. Des données volatiles au début du prompt
  27. 6. Envoyer des schémas ou catalogues entiers
  28. 7. Compter en caractères ou en mots
  29. 8. Supposer que moins de tokens coûte toujours moins cher
  30. 9. Ignorer les tokens de nouvelles tentatives et de raisonnement
  31. Notes de production
  32. Liste de contrôle
  33. Étape suivante
  34. Pour aller plus loin

Problème

Une fonctionnalité LLM marche en test. En production :

  • la facture augmente plus vite que l’usage
  • la latence augmente à mesure que les conversations s’allongent
  • des requêtes atteignent la limite de la fenêtre de contexte
  • les mêmes instructions et schémas sont renvoyés à chaque appel
  • les réponses sont longues alors qu’un court résultat structuré suffirait

Les tokens pilotent trois choses à la fois : le coût, la latence et ce qui tient dans la fenêtre de contexte.

L’objectif n’est pas le prompt le plus court possible. Il s’agit d’envoyer et de générer uniquement ce dont la tâche a besoin, et de prouver que la qualité n’a pas baissé.

Réponse rapide

  1. Mesurez la consommation de tokens par fonctionnalité, par modèle, en entrée et en sortie.
  2. Retirez ce dont le modèle n’a pas besoin : instructions en double, schémas complets, historique périmé, extraits peu pertinents.
  3. Contraignez la sortie : format structuré compact, longueur explicite, plafond de tokens de sortie comme limite de sécurité.
  4. Réutilisez ce qui se répète : un préfixe de prompt stable (mise en cache de prompt côté fournisseur, quand elle existe) et des résultats en cache pour des requêtes identiques.
  5. Routez les tâches simples vers un modèle plus petit, ou vers du code classique.
  6. Revérifiez la qualité sur un jeu d’évaluation après chaque changement.
tokens d'entrée = instructions système + définitions d'outils + exemples
                + historique de conversation + contexte récupéré + résultats d'outils + saisie utilisateur
tokens de sortie = réponse générée (+ tokens de raisonnement, sur les modèles qui les facturent)

Notions de base sur les tokens

  • Les modèles lisent et écrivent des tokens, pas des caractères ni des mots. Un token est un fragment de texte produit par le tokenizer du modèle.
  • Le nombre de tokens dépend du tokenizer : le même texte peut donner des comptes différents selon la famille de modèles.
  • Le code, le JSON, les identifiants longs, les nombres, les espaces et le texte non anglais se découpent souvent moins efficacement que de la prose anglaise.
  • Les estimations à partir des caractères suffisent pour planifier. Pour des chiffres réels, utilisez le tokenizer du modèle ou les champs d’usage renvoyés par l’API.
  • Tout ce qui est dans la requête compte : prompt système, définitions d’outils/fonctions, exemples, historique, documents récupérés, résultats d’outils.
  • La fenêtre de contexte borne ce qu’une requête peut contenir. Selon le modèle, l’entrée et la sortie la partagent, ou la sortie a sa propre limite.

Tokens d’entrée et de sortie

Tokens d’entrée Tokens de sortie
Quoi Tout ce que vous envoyez Tout ce que le modèle génère
Levier Conception du prompt, limites de récupération, politique d’historique Format de sortie, instructions, plafond de tokens de sortie
Tarification Généralement facturés au token Généralement facturés au token, souvent plus cher que l’entrée
Latence Ajoute du temps de traitement avant le premier token Le temps de génération croît avec le nombre de tokens produits

Les prix et le rapport entrée/sortie varient selon le modèle et évoluent dans le temps. Lisez-les dans la grille tarifaire actuelle du fournisseur, jamais dans un aide-mémoire.

Certains modèles génèrent des tokens de raisonnement internes facturés comme sortie même s’ils ne sont pas renvoyés. Vérifiez les champs d’usage.

Pourquoi le contexte répété coûte cher

Les API LLM courantes sont sans état : une « conversation » renvoie l’historique à chaque tour. Le contexte fixe (instructions, schéma, exemples) est repayé à chaque appel, et l’historique grossit à chaque tour.

def cumulative_input_tokens(base: int, per_turn: int, turns: int) -> int:
    """Tokens d'entrée envoyés sur toute une conversation quand l'historique complet est renvoyé à chaque tour."""
    return sum(base + per_turn * (turn - 1) for turn in range(1, turns + 1))


print(cumulative_input_tokens(base=2_000, per_turn=300, turns=20))  # 97000

Avec un contexte fixe de 2 000 tokens et 300 tokens ajoutés par tour, 20 tours envoient 97 000 tokens d’entrée, dont 40 000 correspondent au même contexte fixe répété. La part de l’historique croît à peu près avec le carré du nombre de tours.

Le même calcul s’applique aux pipelines batch : un appel LLM par ligne avec un bloc d’instructions de 1 500 tokens paie ces instructions à chaque ligne.

Code / commandes

1. Mesurer avant d’optimiser

Journalisez l’usage de chaque appel. Faites la correspondance des champs d’usage du fournisseur une seule fois, dans votre wrapper.

import json
import logging
import time

log = logging.getLogger("llm.usage")


def record_usage(feature: str, model: str, prompt_version: str, usage: dict, started: float) -> None:
    """Journalise l'usage en tokens d'un appel. `usage` est le bloc d'usage renvoyé par l'API du fournisseur."""
    log.info(json.dumps({
        "feature": feature,
        "model": model,
        "prompt_version": prompt_version,
        "input_tokens": usage.get("input_tokens"),
        "output_tokens": usage.get("output_tokens"),
        "cached_input_tokens": usage.get("cached_input_tokens", 0),
        "latency_ms": round((time.monotonic() - started) * 1000),
    }))

Journalisez des comptes, pas le texte des prompts : ils peuvent contenir des données sensibles.

Trouvez les plus gros consommateurs (T-SQL sur une table d’usage) :

SELECT
    feature,
    model,
    COUNT(*)                          AS requests,
    AVG(input_tokens)                 AS avg_input_tokens,
    AVG(output_tokens)                AS avg_output_tokens,
    SUM(input_tokens + output_tokens) AS total_tokens
FROM llm_usage_log
WHERE requested_at >= DATEADD(day, -7, SYSUTCDATETIME())
GROUP BY feature, model
ORDER BY total_tokens DESC;

Puis décomposez un prompt représentatif par composant :

def prompt_breakdown(parts: dict[str, str], count_tokens) -> dict[str, int]:
    """Nombre de tokens par composant du prompt ; `count_tokens` est la fonction de tokenisation du modèle."""
    return {name: count_tokens(text) for name, text in parts.items()}

# {"system": 1850, "schema": 4200, "history": 6100, "retrieved": 3900, "question": 40}

Optimisez d’abord le composant le plus gros.


2. Raccourcir et dédoublonner les instructions

Les prompts système longs accumulent des règles répétées, des formules de politesse et des exemples que personne n’a retestés.

Avant :

Tu es un assistant très serviable, attentif et précis. Assure-toi toujours de répondre
avec exactitude. Il est très important d'être exact. Réponds toujours en JSON.
Vérifie que la réponse est en JSON. N'inclus rien d'autre que du JSON dans ta réponse.

Après :

Classe le ticket de support. Renvoie uniquement du JSON conforme au schéma.

Gardez les instructions qui changent le comportement. Supprimez celles qui se répètent, puis relancez le jeu d’évaluation pour confirmer.


3. Garder stables les instructions stables

Placez le contenu fixe en premier et le contenu variable en dernier :

[stable]   rôle, règles, schéma de sortie, exemples
[variable] contexte récupéré, saisie utilisateur

Les prompts sont alors plus faciles à versionner, et la mise en cache de prompt/préfixe côté fournisseur peut fonctionner là où elle est proposée (longueur minimale et expiration dépendent du fournisseur).

N’injectez pas d’horodatage, d’ID de requête ni de nom d’utilisateur dans la partie stable : tout changement au début empêche la réutilisation du préfixe.


4. Résumer ou tronquer l’historique de conversation

Options, de la plus simple à la plus élaborée :

  • garder les N derniers tours
  • garder les N derniers tours plus un résumé glissant des plus anciens
  • garder les faits et décisions extraits au lieu des tours bruts
  • supprimer les résultats d’outils une fois utilisés
def build_history(turns: list[dict], summary: str | None, keep_last: int = 4) -> list[dict]:
    """Garde les derniers tours tels quels et remplace les plus anciens par un résumé glissant."""
    recent = turns[-keep_last:]
    if summary and len(turns) > keep_last:
        return [{"role": "user", "content": f"Résumé de la conversation précédente :\n{summary}"}] + recent
    return recent

Un résumé perd des détails. Demandez au résumeur de conserver mot pour mot les identifiants, les nombres, les noms de tables et les décisions.


5. Limiter le contexte récupéré

Plus d’extraits ne veut pas dire plus de précision. Les extraits peu pertinents coûtent des tokens et peuvent distraire le modèle.

def select_chunks(chunks: list[dict], budget_tokens: int, min_score: float) -> list[dict]:
    """Extraits les mieux notés, sans doublon, qui tiennent dans un budget de tokens."""
    selected, seen, used = [], set(), 0
    for chunk in sorted(chunks, key=lambda c: c["score"], reverse=True):
        if chunk["score"] < min_score or chunk["text_hash"] in seen:
            continue
        if used + chunk["tokens"] > budget_tokens:
            continue
        selected.append(chunk)
        seen.add(chunk["text_hash"])
        used += chunk["tokens"]
    return selected

Ajustez budget_tokens et min_score sur un jeu d’évaluation ; il n’existe pas de top-k universel.


6. Découper seulement quand c’est utile

Le découpage (chunking) sert la récupération dans de grands corpus. Il n’est pas toujours nécessaire :

  • un document court, entièrement pertinent, peut être envoyé une fois
  • les données structurées gagnent généralement à être interrogées (SQL, agrégats) plutôt que découpées en texte
  • des extraits trop petits perdent leur contexte ; des extraits trop grands gaspillent des tokens

7. Envoyer le schéma utile, pas tout le catalogue

Pour générer du SQL, n’envoyez que les tables et colonnes nécessaires à la question, sous une forme compacte :

orders(order_id int pk, customer_id int fk->customers, order_date date,
       status varchar -- 'open' | 'shipped' | 'cancelled', amount decimal(12,2))
customers(customer_id int pk, country char(2), segment varchar)

Présélectionnez les tables par recherche dans les métadonnées ou par une étape de récupération au niveau des tables. N’ajoutez des descriptions que là où un nom est ambigu.


8. Demander des formats de sortie concis

Indiquez le format et la longueur attendus :

Renvoie uniquement du JSON conforme au schéma. Aucune explication. "reason" : 15 mots maximum.

Fixez aussi un plafond de tokens de sortie, mais comme limite de sécurité, pas comme moyen de raccourcir les réponses : un plafond trop bas coupe la sortie au milieu du JSON.


9. Sortie structurée ou prose verbeuse

Prose :

Après examen attentif du ticket, il semble que le client rencontre très probablement
un problème de facturation, puisqu'il indique avoir été débité deux fois...

Structurée :

{"label": "billing_issue", "confidence": 0.82, "evidence": "débité deux fois"}

La sortie structurée est généralement plus courte, plus facile à valider et à stocker. Les clés coûtent aussi des tokens : gardez-les courtes mais lisibles. Utilisez la fonction de sortie structurée / schéma JSON du fournisseur quand elle existe, et validez quand même.


10. Mettre en cache le contexte stable et les résultats

Deux mécanismes différents :

  • Mise en cache de prompt/préfixe (fonction du fournisseur, quand elle existe) : des préfixes identiques répétés peuvent être facturés et traités à moindre coût. Les conditions d’éligibilité varient.
  • Cache de résultats applicatif : des entrées identiques renvoient une réponse stockée sans appeler le modèle.
import hashlib
import json


def cache_key(model: str, prompt_version: str, payload: dict) -> str:
    """Clé stable pour un cache de résultats : même modèle, même version de prompt, entrée normalisée."""
    raw = json.dumps({"m": model, "v": prompt_version, "p": payload}, sort_keys=True, ensure_ascii=False)
    return hashlib.sha256(raw.encode("utf-8")).hexdigest()

Un cache de résultats n’aide que si les entrées se répètent. Incluez la version du prompt et le modèle dans la clé, et fixez une expiration quand les données sous-jacentes changent.


11. Router les tâches vers le bon modèle, ou vers aucun

def route(task: str, text: str) -> str:
    if task in {"parse_date", "extract_email"}:
        return "code"            # analyseur déterministe : pas d'appel LLM
    if task in {"classify_ticket", "extract_fields"} and len(text) < 4_000:
        return "small-model"
    return "large-model"

Le routage ne réduit pas le nombre de tokens ; il rend chaque token moins cher et souvent plus rapide. Escaladez vers un modèle plus grand quand la validation échoue, au lieu de tout envoyer au plus gros.


12. Regrouper les petits éléments quand la tâche le permet

Plusieurs enregistrements par appel partagent une seule copie des instructions :

{"records": [
  {"id": "t-101", "text": "Remboursement non reçu"},
  {"id": "t-102", "text": "Connexion impossible après réinitialisation"}
]}

Exigez les ID dans la sortie et vérifiez que chaque ID d’entrée revient exactement une fois. Des lots trop gros peuvent dégrader la qualité, et un échec touche alors de nombreux enregistrements.

Tableau de décision des techniques

Technique Réduit les tokens d’entrée Réduit les tokens de sortie Risque principal
Raccourcir / dédoublonner le prompt système Oui — Supprimer une instruction dont le modèle dépendait
Résumer l’historique Oui — Perdre des faits, des ID ou des décisions
Réduire les extraits récupérés Oui — Écarter l’extrait qui contenait la réponse
N’envoyer que le schéma utile Oui — Mauvaise présélection de tables, SQL faux
Demander un JSON compact — Oui Moins d’explications pour les lecteurs humains
Plafonner les tokens de sortie — Borne le pire cas Sortie tronquée ou invalide
Mise en cache de prompt/préfixe Réduit le coût de l’entrée répétée, si disponible — Tout changement de préfixe l’annule ; règles propres au fournisseur
Mettre en cache les résultats Requête entière évitée Requête entière évitée Réponses périmées, mauvaise clé de cache
Router les tâches simples vers un modèle plus petit Mêmes tokens, moins chers Mêmes tokens, moins chers Qualité moindre sur les cas difficiles
Regrouper les enregistrements par appel Oui, instructions partagées Légèrement Échecs partiels, ID incohérents

Les gains dépendent de la charge de travail. Mesurez-les ; ne supposez pas de pourcentage.

Points à vérifier

  • Quel composant domine l’entrée : instructions, schéma, historique, récupération ou résultats d’outils ?
  • Le rapport sortie/entrée par fonctionnalité.
  • Les tokens par requête au p50 et au p95, pas seulement la moyenne.
  • Les requêtes proches de la limite de la fenêtre de contexte.
  • Les nouvelles tentatives : une validation en échec fait payer la requête deux fois.
  • Le taux de succès du cache, si vous en utilisez un.
  • Dans les boucles d’agents ou d’outils, les résultats d’outils réinjectés à chaque étape.

Erreurs fréquentes

1. Optimiser sans référence

Sans jeu d’évaluation, impossible de savoir si un prompt plus court est moins cher et toujours correct.

2. Utiliser le plafond de tokens de sortie pour raccourcir les réponses

Le modèle ne planifie pas en fonction du plafond ; la sortie est coupée. Demandez la concision dans les instructions et gardez le plafond comme limite de sécurité.

3. Faire disparaître les identifiants dans les résumés

« L’utilisateur a posé une question sur une table » ne sert à rien. Gardez sales.orders, la plage de dates et la décision prise.

4. Récupérer un top-20 « au cas où »

Les extraits en trop coûtent des tokens et peuvent orienter le modèle vers la mauvaise source.

5. Des données volatiles au début du prompt

Des horodatages ou des ID d’utilisateur dans les premières lignes annulent la mise en cache de préfixe et rendent les diffs de prompts illisibles.

6. Envoyer des schémas ou catalogues entiers

Des milliers de colonnes pour une question qui porte sur deux tables.

7. Compter en caractères ou en mots

Les estimations dérivent, surtout pour le code, le JSON et le texte non anglais. Utilisez le tokenizer ou les champs d’usage de l’API.

8. Supposer que moins de tokens coûte toujours moins cher

Un prompt plus court qui provoque des nouvelles tentatives, des escalades ou des réponses fausses peut coûter plus cher par tâche réussie.

9. Ignorer les tokens de nouvelles tentatives et de raisonnement

Ils apparaissent sur la facture, pas dans votre prompt.

Notes de production

  • Versionnez les prompts et journalisez la version avec l’usage, pour relier un changement de coût à un changement de prompt.
  • Définissez des budgets de tokens par fonctionnalité, avec des alertes.
  • Relancez l’évaluation de qualité après chaque optimisation.
  • Les tokenizers et les prix dépendent du modèle : mesurez à nouveau en changeant de modèle.
  • Gardez de la marge dans la fenêtre de contexte pour la sortie.
  • Journalisez les comptes de tokens, pas les prompts bruts, quand ils peuvent contenir des données clients ou sensibles.

Liste de contrôle

  • L’usage est journalisé par fonctionnalité, modèle et version de prompt.
  • Le plus gros composant du prompt est connu.
  • Les instructions sont dédoublonnées et testées.
  • Le contenu stable vient en premier, le contenu volatil en dernier.
  • L’historique suit une politique de conservation ou de résumé.
  • La récupération a un budget de tokens et un seuil de pertinence.
  • Seul le schéma utile est envoyé.
  • Le format de sortie est compact et validé.
  • Le plafond de tokens de sortie sert de limite de sécurité.
  • Le cache n’est utilisé que là où les entrées ou les préfixes se répètent vraiment.
  • Les tâches simples sont routées vers des modèles moins chers ou vers du code.
  • La qualité est revérifiée après chaque changement.

Étape suivante

  • Besoin d’estimer la dépense mensuelle → Coût LLM et budget de tokens.
  • La plupart des tokens viennent de l’historique ou de la récupération → Ingénierie du contexte pour les LLM.
  • Un modèle plus petit pourrait suffire → Choisir le bon modèle d’IA.
  • Les prompts sont longs parce que les instructions sont floues → Patrons de prompts pour l’ingénierie des données.

← Tous les aide-mémoire