Compromis entre coût et latence
Budgets de tokens de réflexion, coûts d’inférence et stratégies de routage hybrides.
Compromis entre coût et latence est une leçon AI Prompt Engineering gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage AI Prompt Engineering, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours AI Prompt Engineering comprend 4 leçons au total.
Le triangle coût-qualité-latence
Dans la conception de systèmes LLM, il existe un triangle fondamental : le coût, la qualité et la latence. Vous ne pouvez optimiser au maximum que deux de ces trois critères à un moment donné.
- Faible coût + qualité élevée = lent (modèles de raisonnement, génération lente)
- Faible coût + faible latence = qualité moindre (modèles petits et rapides)
- Qualité élevée + faible latence = coûteux (modèle de raisonnement avec diffusion en continu)
Chaque décision d'architecture implique un compromis dans ce triangle.
Tarification des modèles de raisonnement
Les jetons de réflexion coûtent plus cher en plus des jetons d'entrée et de sortie standard. Le coût d'un appel à un modèle de raisonnement comprend : les jetons d'entrée + les jetons de réflexion + les jetons de sortie.
Par rapport aux modèles rapides et compacts : o3 est environ 20 fois plus cher que GPT-4o-mini par jeton ; Claude Opus avec réflexion étendue est environ 10 à 15 fois plus cher que Claude Haiku par jeton de sortie.
# Rough cost estimates (2025 pricing, may change)
# Source: provider pricing pages
PRICING = {
# (input $/1M tokens, output $/1M tokens)
'gpt-4o-mini': (0.15, 0.60),
'gpt-4o': (2.50, 10.00),
'o3-mini': (1.10, 4.40),
'o3': (10.0, 40.00),
'claude-haiku-4-5': (0.25, 1.25),
'claude-sonnet-4-5': (3.00, 15.00),
'claude-opus-4-5': (15.0, 75.00),
}
def estimate_cost(model, input_tokens, output_tokens, thinking_tokens=0):
inp_price, out_price = PRICING[model]
# Thinking tokens billed as output tokens
total_out = output_tokens + thinking_tokens
cost = (input_tokens / 1e6 * inp_price) + (total_out / 1e6 * out_price)
return cost
# A single hard question with 8000 thinking tokens:
cost = estimate_cost('claude-opus-4-5', 500, 300, thinking_tokens=8000)
print(f'Cost per call: ${cost:.4f}')Surcoût des jetons de réflexion
Les jetons de réflexion sont souvent bien plus nombreux que les jetons de sortie. Une réponse concise de 200 mots peut reposer sur 5 000 à 15 000 jetons de réflexion. Ces jetons de réflexion coûtent autant que les jetons de sortie.
C'est pourquoi le multiplicateur de coût des modèles de raisonnement dépend principalement des jetons de réflexion, et non de la longueur de la réponse.
import anthropic
client = anthropic.Anthropic(api_key='sk-ant-...')
def analyze_token_breakdown(question, budget_tokens):
response = client.messages.create(
model='claude-opus-4-5',
max_tokens=budget_tokens + 2000,
thinking={'type': 'enabled', 'budget_tokens': budget_tokens},
messages=[{'role': 'user', 'content': question}]
)
# Usage breakdown
usage = response.usage
print(f'Input tokens: {usage.input_tokens:,}')
print(f'Output tokens: {usage.output_tokens:,}')
# Thinking tokens are in cache_creation_input_tokens on some APIs
# or can be estimated from thinking block content length
thinking_blocks = [b for b in response.content if b.type == 'thinking']
est_thinking = sum(len(b.thinking.split()) * 1.3 for b in thinking_blocks)
print(f'Est. thinking tokens: {int(est_thinking):,}')
answer = next(b.text for b in response.content if b.type == 'text')
print(f'Answer words: {len(answer.split())}')
analyze_token_breakdown(
'Explain the trade-offs between REST and GraphQL APIs.',
budget_tokens=5000
)Latence : à quoi s'attendre
Plages de latence observées pour différentes configurations de modèles, qui varient considérablement selon la charge et la difficulté du problème :
- Claude Haiku : 0,5 à 2 secondes
- Claude Sonnet : 2 à 8 secondes
- Claude Opus (sans réflexion) : 5 à 15 secondes
- Claude Opus (réflexion 5K) : 15 à 40 secondes
- Claude Opus (réflexion 16K) : 40 à 90 secondes
- o3 (effort élevé) : 30 à 120 secondes
import time
import anthropic
client = anthropic.Anthropic(api_key='sk-ant-...')
def benchmark_latency(prompt, model, budget_tokens=None):
kwargs = {
'model': model,
'max_tokens': 2000,
'messages': [{'role': 'user', 'content': prompt}]
}
if budget_tokens:
kwargs['thinking'] = {'type': 'enabled', 'budget_tokens': budget_tokens}
kwargs['max_tokens'] = budget_tokens + 2000
start = time.time()
response = client.messages.create(**kwargs)
elapsed = time.time() - start
answer = response.content[-1].text
print(f'{model} (budget={budget_tokens}): {elapsed:.1f}s')
return elapsed, answer
benchmark_latency('Name 3 planets', 'claude-haiku-4-5')
benchmark_latency('Solve x^2 - 5x + 6 = 0', 'claude-opus-4-5', 3000)
benchmark_latency('Design a fault-tolerant payment system', 'claude-opus-4-5', 10000)Délai avant le premier jeton avec diffusion en continu
Bien que la latence totale des modèles de raisonnement soit élevée, le délai avant le premier jeton (TTFT) avec la diffusion en continu peut être bien plus faible : le modèle commence à diffuser la réponse immédiatement après avoir terminé sa réflexion. Affichez rapidement quelque chose à l'utilisateur en diffusant la réponse en continu.
import anthropic
import time
client = anthropic.Anthropic(api_key='sk-ant-...')
def stream_with_timing(prompt):
start = time.time()
first_token_time = None
full_text = ''
with client.messages.stream(
model='claude-opus-4-5',
max_tokens=10000,
thinking={'type': 'enabled', 'budget_tokens': 5000},
messages=[{'role': 'user', 'content': prompt}]
) as stream:
in_answer = False
for text_chunk in stream.text_stream:
if not in_answer:
in_answer = True
first_token_time = time.time() - start
print(f'Time to first answer token: {first_token_time:.1f}s')
full_text += text_chunk
print(text_chunk, end='', flush=True)
total_time = time.time() - start
print(f'\nTotal time: {total_time:.1f}s')
stream_with_timing('List 5 key benefits of microservices.')Modèle d'architecture hybride
Un modèle pratique pour la production consiste à utiliser d'abord un modèle standard rapide. Si le résultat est satisfaisant, vérifiez-le avec votre métrique de qualité, puis renvoyez-le immédiatement. Dans le cas contraire, transmettez la requête à un modèle de raisonnement. Vous obtenez ainsi une latence et un coût moyens faibles, tout en conservant une grande précision pour les cas difficiles.
import anthropic
client = anthropic.Anthropic(api_key='sk-ant-...')
def hybrid_query(question, quality_threshold=0.7):
# Step 1: Try fast model first
r_fast = client.messages.create(
model='claude-haiku-4-5',
max_tokens=300,
messages=[{'role': 'user', 'content': question}]
)
fast_answer = r_fast.content[0].text
# Step 2: Quick confidence check
confidence_check = client.messages.create(
model='claude-haiku-4-5',
max_tokens=20,
messages=[{
'role': 'user',
'content': (
f'Q: {question}\nA: {fast_answer}\n'
f'Rate answer quality 0.0-1.0. Number only:'
)
}]
)
try:
quality = float(confidence_check.content[0].text.strip())
except ValueError:
quality = 0.5
if quality >= quality_threshold:
return fast_answer, 'fast'
# Step 3: Escalate to reasoning model
r_slow = client.messages.create(
model='claude-opus-4-5',
max_tokens=8000,
thinking={'type': 'enabled', 'budget_tokens': 6000},
messages=[{'role': 'user', 'content': question}]
)
return next(b.text for b in r_slow.content if b.type == 'text'), 'reasoning'Coût à grande échelle : faire les calculs
Les modèles de raisonnement qui semblent abordables lors des essais deviennent des sources de coûts importantes à grande échelle. Projetez toujours les coûts avant de choisir une architecture.
def project_monthly_cost(daily_queries, model_config):
"""
Project monthly API costs for different configurations.
model_config: dict with 'cost_per_query' key
"""
monthly_queries = daily_queries * 30
monthly_cost = monthly_queries * model_config['cost_per_query']
print(f'Daily queries: {daily_queries:,}')
print(f'Monthly queries: {monthly_queries:,}')
print(f'Cost per query: ${model_config["cost_per_query"]:.4f}')
print(f'Monthly cost: ${monthly_cost:,.2f}')
return monthly_cost
# Compare configurations at 10,000 queries/day
configs = [
{'name': 'All Haiku', 'cost_per_query': 0.0005},
{'name': 'All Sonnet', 'cost_per_query': 0.015},
{'name': 'All Opus+Thinking', 'cost_per_query': 0.85},
{'name': 'Hybrid (90% Haiku, 10% Opus)', 'cost_per_query': 0.9*0.0005 + 0.1*0.85},
]
for config in configs:
print(f'\n--- {config["name"]} ---')
project_monthly_cost(10_000, config)Mise en cache des invites pour réduire les coûts
Pour les appels à des modèles de raisonnement comportant de longues invites système ou un contexte répété, utilisez la mise en cache des invites. Les jetons mis en cache coûtent 90 % moins cher que ceux qui ne le sont pas. Cette optimisation est particulièrement efficace lorsque le même contexte volumineux, comme des documents ou du code, est envoyé à plusieurs reprises.
import anthropic
client = anthropic.Anthropic(api_key='sk-ant-...')
LONG_CONTEXT = 'A' * 50000 # Simulated large document
# With prompt caching: mark large context as cacheable
response = client.messages.create(
model='claude-opus-4-5',
max_tokens=10000,
thinking={'type': 'enabled', 'budget_tokens': 6000},
system=[
{
'type': 'text',
'text': f'You are analyzing this document: {LONG_CONTEXT}',
'cache_control': {'type': 'ephemeral'} # Cache this prefix
}
],
messages=[{
'role': 'user',
'content': 'What are the main themes in this document?'
}]
)
usage = response.usage
print(f'Cache read tokens: {getattr(usage, "cache_read_input_tokens", 0):,}')
print(f'Cache creation tokens: {getattr(usage, "cache_creation_input_tokens", 0):,}')
# Second call with same system content costs ~90% less on cached tokensTraitement par lots pour réduire les coûts
OpenAI et Anthropic proposent toutes deux des API de traitement par lots avec une réduction de 50 % pour les requêtes qui ne sont pas urgentes. Si vous disposez d'un grand volume de requêtes pouvant attendre plusieurs heures leurs résultats, le traitement par lots est l'option la plus économique.
import anthropic
import json
client = anthropic.Anthropic(api_key='sk-ant-...')
# Batch API: 50% cheaper, 24-hour turnaround
requests = [
{
'custom_id': f'query_{i}',
'params': {
'model': 'claude-opus-4-5',
'max_tokens': 1024,
'messages': [{'role': 'user', 'content': f'Analyze dataset row {i}'}]
}
}
for i in range(100) # 100 queries in one batch
]
# Submit batch
batch = client.messages.batches.create(requests=requests)
print(f'Batch ID: {batch.id}')
print(f'Status: {batch.processing_status}')
print(f'Requests: {batch.request_counts}')
# Poll batch.id for results when processing_status == 'ended'Optimisation du budget de jetons
Adaptez budget_tokens à la classe de votre problème. Utiliser un budget de 16K pour un problème simple gaspille des jetons et augmente la latence. Créez une table de consultation du budget fondée sur des niveaux de difficulté.
BUDGET_LOOKUP = {
'simple_math': 1000, # Arithmetic, basic algebra
'medium_code': 3000, # Function implementation, debugging
'complex_reasoning': 8000, # System design, complex analysis
'research_grade': 16000, # Proofs, research-level problems
}
def budget_for_query(query):
q_lower = query.lower()
if any(kw in q_lower for kw in ['calculate', 'what is', 'how many', 'convert']):
return BUDGET_LOOKUP['simple_math']
elif any(kw in q_lower for kw in ['code', 'function', 'bug', 'implement']):
return BUDGET_LOOKUP['medium_code']
elif any(kw in q_lower for kw in ['design', 'architecture', 'analyze', 'strategy']):
return BUDGET_LOOKUP['complex_reasoning']
else:
return BUDGET_LOOKUP['medium_code'] # Safe default
print(budget_for_query('What is 15% of 340?')) # 1000
print(budget_for_query('Implement a trie in Python')) # 3000
print(budget_for_query('Design a CDC pipeline')) # 8000Définir des SLA pour les applications LLM
Avant de choisir entre des modèles standard et des modèles de raisonnement, définissez les exigences de votre application en matière d'accord de niveau de service (SLA) :
- Latence P50 : expérience utilisateur habituelle
- Latence P99 : expérience utilisateur dans le pire des cas
- Budget de jetons : coût maximal par requête utilisateur
- Seuil minimal de qualité : précision minimale acceptable sur votre jeu d'évaluation
Les modèles de raisonnement dépassent facilement les exigences de latence P99 des SLA pour les applications interactives. Connaissez vos contraintes avant d'arrêter vos décisions d'architecture.
Vérification des connaissances : coûts des modèles de raisonnement
Quel est le principal facteur expliquant les coûts élevés des modèles de raisonnement par rapport aux modèles standard ?
Récapitulatif : compromis entre coût et latence
Les modèles de raisonnement sont coûteux : les jetons de réflexion sont facturés comme des jetons de sortie et peuvent être 10 à 50 fois plus nombreux que la réponse visible. La latence varie de 15 à 120 secondes pour les problèmes difficiles. Réduisez ces coûts et ces délais grâce au modèle hybride, avec un modèle rapide en premier et une transmission à un modèle plus puissant uniquement lorsque la confiance est faible, à la mise en cache des invites pour les contextes volumineux répétés, avec une réduction de 90 % sur les jetons mis en cache, à l'API de traitement par lots pour les traitements hors ligne, avec une réduction de 50 %, et à l'adaptation de budget_tokens à la difficulté du problème. À grande échelle, même de petits coûts par requête se transforment en factures mensuelles importantes : projetez toujours les coûts avant de vous engager dans une architecture.
Apprends AI Prompt Engineering avec un tuteur IA — gratuit
Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.
- Cours
- 53
- Leçons
- 199
Questions Fréquemment Posées
La leçon « Compromis entre coût et latence » est-elle gratuite ?
Oui — le texte complet de « Compromis entre coût et latence » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours AI Prompt Engineering, passe à CoddyKit PRO. Le cours AI Prompt Engineering comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Compromis entre coût et latence » ?
Budgets de tokens de réflexion, coûts d’inférence et stratégies de routage hybrides. Tu pratiques AI Prompt Engineering avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer AI Prompt Engineering ?
Aucune expérience préalable n'est requise. AI Prompt Engineering sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.
Combien de temps prend la leçon « Compromis entre coût et latence » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon AI Prompt Engineering ?
Oui. Chaque leçon AI Prompt Engineering inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Différences entre les modèles de raisonnement
- Prompts efficaces pour la réflexion approfondie
- Quand utiliser des modèles de raisonnement ou standard
- Compromis entre coût et latence