+150 XP

Coût, latence et choix du modèle : les arbitrages

Une startup a fait passer 2 millions d'avis clients dans un modèle de raisonnement frontier (GPT-5 avec les paramètres par défaut) pour les classer en « positif », « négatif » ou « neutre ». Ça a très bien marché. Ça a aussi pris 9 heures et coûté environ 1 500 $, dépensés pour l'essentiel en tokens de « réflexion » cachés dont personne n'avait besoin. L'équipe est passée à un petit modèle rapide, avec le raisonnement réduit. Même tâche : 40 minutes, environ 40 $, et une précision en baisse de moins de 1 %.

Toute la leçon tient dans cette histoire. Le plus gros modèle est rarement le bon choix pour un travail répétitif à fort volume. Voici comment raisonner.

Trois paramètres toujours en arbitrage

Chaque fois que vous choisissez un modèle, vous arbitrez entre trois paramètres :

  • Qualité : le niveau du résultat produit.
  • Latence : le temps d'attente avant la réponse. (La latence, c'est simplement le délai.)
  • Coût : ce que vous payez par requête.

En général, vous pouvez optimiser deux de ces paramètres, pas les trois. Un très gros modèle frontier offre la meilleure qualité, mais coûte plus cher et tourne plus lentement. Un petit modèle est économique et rapide, mais peut buter sur les tâches difficiles.

La compétence consiste à adapter le modèle à la tâche, pas à prendre systématiquement le plus puissant.

Pourquoi les gros modèles sont plus lents et plus chers

Les grands modèles de langage facturent au token, un token représentant environ les 3/4 d'un mot. « Customer service » fait à peu près 2 à 3 tokens.

Les gros modèles ont davantage de « paramètres » internes (les réglages ajustés pendant l'entraînement). Plus de paramètres signifie plus de calcul par token, donc plus de coût et plus de délai.

Il existe un second coût, facile à rater. Beaucoup de modèles actuels (GPT-5, Claude avec extended thinking, Gemini 2.5 Pro) sont des modèles de raisonnement : avant de répondre, ils génèrent des tokens de raisonnement cachés. Vous ne les voyez jamais, mais vous les payez au tarif de sortie et vous les attendez. Pour une réponse d'un mot, un modèle peut « réfléchir » pendant des centaines de tokens.

Un modèle frontier peut donc facilement coûter 10 à 50 fois plus cher par requête qu'un petit modèle et répondre plusieurs fois plus lentement. Sur une requête, la différence ne se voit pas. Sur 2 millions de requêtes, c'est tout votre budget.

Un exemple concret : la tâche de classification

Rendons concret le tri des avis.

Vous avez 2 millions d'avis. Chacun est court (disons 50 tokens en entrée, un mot en sortie, juste le label). Vous voulez que chacun soit étiqueté positif, négatif ou neutre. C'est de la classification : ranger des éléments dans des catégories fixes.

Voici le prompt que vous enverriez pour chaque avis :

Classify the sentiment of this review as exactly one word:
positive, negative, or neutral.

Review: "Shipping was slow but the product is excellent."

Answer:

C'est une tâche facile. Même les petits modèles gèrent bien le sentiment. Vous n'avez pas besoin d'un modèle capable d'écrire de la poésie ou de déboguer du code. Il vous faut un modèle qui lit trois phrases et renvoie un mot, vite et pour pas cher.

Faites le calcul

Tarifs approximatifs fin 2026 (vérifiez toujours les prix en vigueur, ils changent souvent) :

Type de modèleCoût par million de tokens en entréeCoût par million de tokens en sortieVitesse relative
Frontier (GPT-5, Claude Opus, Gemini Pro)~1,25 $ à 5 $~10 $ à 25 $Plus lent
Petit/rapide (GPT-5 mini ou nano, Claude Haiku, Gemini Flash)~0,05 $ à 1 $~0,40 $ à 5 $Beaucoup plus rapide

Pour 2 millions d'avis à ~50 tokens chacun, cela fait 100 millions de tokens en entrée.

  • Modèle frontier : environ 125 $ à 500 $ pour la seule entrée. Ajoutez quelques centaines de tokens de raisonnement cachés par avis au tarif de sortie, et la facture grimpe à plusieurs milliers de dollars, avec de nombreuses heures de traitement.
  • Petit modèle avec un raisonnement minimal : environ 5 $ à 100 $, en une fraction du temps.

Le petit modèle l'emporte nettement, à condition que la précision tienne. Pour une tâche aussi simple, c'est généralement le cas. C'est le point à vérifier, ce qui nous amène aux tests.

Comment décider vraiment : tester, pas deviner

Ne supposez jamais que le petit modèle suffit. Mesurez-le. Voici la démarche.

Étape 1 : constituer un petit jeu de test étiqueté

Étiquetez vous-même à la main 100 à 200 avis. C'est votre vérité terrain : les bonnes réponses auxquelles vous comparez les résultats.

Étape 2 : faire tourner les deux modèles sur le jeu de test

python
from openai import OpenAI
client = OpenAI()

def classify(review, model):
    resp = client.chat.completions.create(
        model=model,
        messages=[{
            "role": "user",
            "content": f"Classify sentiment as one word "
                       f"(positive, negative, neutral): {review}"
        }],
        reasoning_effort="minimal",   # évite l'essentiel de la réflexion cachée
        max_completion_tokens=16,     # inclut les tokens de raisonnement
    )
    return (resp.choices[0].message.content or "").strip().lower()

# Comparer un petit modèle et un gros
for model in ["gpt-5-mini", "gpt-5"]:
    correct = sum(
        classify(r["text"], model) == r["label"]
        for r in test_set
    )
    print(model, correct / len(test_set))

Deux détails comptent ici. Les modèles de raisonnement refusent l'ancien paramètre max_tokens : il faut utiliser max_completion_tokens. Et ce plafond compte aussi les tokens de raisonnement cachés. Fixez-le à 1 et le modèle risque de consacrer son unique token à réfléchir et de ne rien renvoyer du tout.

Étape 3 : comparer la précision et décider

Mettons que le gros modèle obtienne 96 % et le petit 95 %. Cet écart de 1 %, sur une tâche de tri d'avis, ne justifie presque jamais un coût 10 fois supérieur et des traitements plus lents. Passez en production avec le petit modèle.

Si l'écart était de 96 % contre 78 %, ce serait différent. Vous garderiez alors le gros modèle, ou vous amélioreriez le prompt du petit.

Pour une bonne introduction gratuite à ce type d'évaluation, consultez le guide Evals d'OpenAI, qui explique comment construire des jeux de test et noter les résultats.

Des patterns plus malins que « en choisir un seul »

Vous n'êtes pas obligé de vous engager sur un seul modèle. Certaines des meilleures architectures les combinent.

Pattern 1 : la cascade (le moins cher d'abord, le plus cher sur les cas difficiles)

Faites tout passer par le petit modèle. Quand il hésite, transmettez au gros.

Vous pouvez demander au modèle un score de confiance, ou regarder les probabilités des tokens quand l'API les expose. Si la confiance est faible, envoyez cet élément seul au modèle frontier. Si 90 % des avis sont faciles, vous ne payez le tarif du gros modèle que sur 10 % du travail.

Pattern 2 : le mode batch pour les tâches non urgentes

Si vous n'avez pas besoin des réponses immédiatement, utilisez le traitement par batch. Vous soumettez un gros volume de requêtes et récupérez les résultats dans un délai donné (généralement jusqu'à 24 heures), pour environ moitié prix.

OpenAI, Anthropic et Google proposent tous des API batch. Pour nos 2 millions d'avis, où personne n'attend en temps réel, le mode batch est idéal : la latence n'a pas d'importance, vous l'échangez donc contre du coût.

Pattern 3 : adapter la latence à la personne en face

  • Un chatbot en direct où quelqu'un attend : la latence compte beaucoup. Choisissez un modèle rapide et gardez un effort de raisonnement faible.
  • Un rapport nocturne qui tourne pendant que tout le monde dort : la latence compte à peine. Optimisez le coût ou la qualité.

Posez-vous la question : « Est-ce qu'un humain fixe une icône de chargement ? » Si ce n'est pas le cas, vous avez de la marge pour économiser.

Vérification des acquis

1. Selon la leçon, quel est le principe central pour adapter un modèle à une tâche ?

2. La leçon décrit trois paramètres toujours en arbitrage lors du choix d'un modèle. Quelle contrainte principale souligne-t-elle à leur sujet ?

3. Pourquoi les gros modèles sont-ils à la fois plus lents et plus chers par token ?

CHOIX MULTIPLES

4. Sélectionnez TOUTES les raisons pour lesquelles la tâche de classification (tri par sentiment) convient bien à un petit modèle rapide.

Sélectionnez toutes les réponses correctes.

CHOIX MULTIPLES

5. Sélectionnez TOUTES les affirmations qui reflètent correctement les arbitrages décrits dans la leçon.

Sélectionnez toutes les réponses correctes.

Erreurs fréquentes

Prendre par défaut le plus gros modèle « par sécurité ». C'est l'habitude la plus coûteuse des projets d'IA. Cette sécurité coûte de l'argent réel et ajoute du délai, sans gain de qualité sur les tâches faciles.

Laisser le raisonnement activé pour des tâches triviales. Un modèle de raisonnement à l'effort par défaut peut réfléchir pendant des centaines de tokens avant d'écrire « positive ». Réduisez l'effort (reasoning_effort="minimal" ou "low" chez OpenAI, ou laissez l'extended thinking désactivé sur Claude) quand la tâche n'en a pas besoin.

Tester sur trois exemples et s'arrêter là. Trois avis ne vous apprennent rien. Il vous faut un jeu de test assez grand pour être fiable, plus de 100 exemples pour une tâche simple.

Ignorer la longueur de la sortie. Les tokens de sortie coûtent plusieurs fois plus cher que les tokens d'entrée. Un modèle bavard coûte plus cher qu'un modèle qui répond en un mot. Pour la classification, demandez un seul mot et fixez un plafond de sortie bas, en laissant un peu de marge pour d'éventuels tokens de raisonnement.

Oublier que le prompt peut sauver un petit modèle. Souvent, un petit modèle échoue parce que le prompt est flou, pas parce que le modèle est faible. Ajouter un exemple clair (on parle d'exemple few-shot) peut combler l'écart :

Example:
Review: "Arrived broken and support ignored me."
Answer: negative

Now classify:
Review: "Works fine, nothing special."
Answer:

Ce seul exemple peut faire gagner plusieurs points de précision à un petit modèle, souvent assez pour éviter de payer un modèle plus gros.

Une checklist de décision simple

Avant de choisir un modèle, posez-vous ces questions :

  1. Quelle est la difficulté réelle de la tâche ? Trier et extraire, c'est facile. La rédaction nuancée et le raisonnement en plusieurs étapes, c'est difficile.
  2. Combien de requêtes ? Un usage ponctuel : la qualité l'emporte. Des millions : le coût et la vitesse dominent.
  3. Un humain attend-il ? Oui : priorité à la latence. Non : passez en batch.
  4. La tâche demande-t-elle du raisonnement ? Sinon, réduisez-le ou désactivez-le.
  5. Quel est le seuil de précision ? Fixez le score minimum acceptable avant de tester, pour ne pas rationaliser après coup.
  6. Ai-je vraiment mesuré ? Si vous n'avez pas fait tourner de jeu de test, vous devinez.

Appliquez ces questions à la tâche sur les avis et la réponse est évidente : tâche facile, volume énorme, personne n'attend, le petit modèle passe le seuil de précision. Prenez le petit, en mode batch, avec un raisonnement minimal et un plafond de sortie serré.

Points clés

  • Adaptez le modèle à la tâche, pas à votre ego. Pour un travail facile et à fort volume comme la classification, un petit modèle rapide bat généralement un modèle frontier en coût et en vitesse, avec une perte de qualité quasi nulle.
  • Les tokens de raisonnement cachés sont facturés comme de la sortie et ajoutent du délai. Gardez un effort de raisonnement faible sur les tâches simples.
  • Testez toujours sur un jeu étiqueté de plus de 100 exemples avant de vous engager. Comparez directement la précision et fixez votre seuil acceptable à l'avance.
  • Utilisez le mode batch quand aucun humain n'attend, pour réduire les coûts d'environ moitié, et plafonnez la longueur de sortie (avec max_completion_tokens sur les modèles de raisonnement) pour ne pas payer le bavardage.
  • Recourez aux cascades (petit modèle d'abord, cas difficiles transmis au gros) pour obtenir la qualité d'un gros modèle sur les quelques éléments qui en ont besoin.
  • Améliorez le prompt avant de monter en gamme de modèle. Un seul exemple few-shot comble souvent l'écart et vous épargne totalement la montée en gamme.

À faire, tiré de cette leçon

Ces actions sont compilées dans le plan d'action du rôle.

  • Utiliser de petits modèles rapides en batch pour les tâches faciles à fort volume
Voir le plan d'action complet →

Articles liés

Les articles récents du blog qui s'appuient sur cette leçon.