Différences entre les modèles de raisonnement
Chaîne de pensée interne contre modèles standard : ce qui change pour l’auteur du prompt.
Différences entre les modèles de raisonnement est une leçon AI Prompt Engineering gratuite sur CoddyKit. Ceci est la leçon 1 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.
Que sont les modèles de raisonnement ?
Les modèles de raisonnement sont des LLM spécialement entraînés et configurés pour mener une délibération interne prolongée avant de produire une réponse. Parmi eux figurent les modèles des séries o1/o3/o4 d'OpenAI et Claude d'Anthropic avec la réflexion prolongée activée.
Contrairement aux modèles standard, qui génèrent directement le texte jeton par jeton à partir de votre invite, les modèles de raisonnement produisent d'abord une longue chaîne de raisonnement interne, puis la résument dans une réponse finale.
Modèle standard ou de raisonnement : ce que vous voyez
Du point de vue de l'utilisateur de l'API, la différence est la suivante :
- Modèle standard : entrée → sortie (rapide et direct)
- Modèle de raisonnement : entrée → [réflexion interne, masquée ou transmise en continu] → sortie (plus lent, mais plus précis pour les problèmes difficiles)
Le processus de réflexion constitue le brouillon privé du modèle. Il peut contenir des fausses pistes, des autocorrections et des calculs intermédiaires qui n'apparaissent jamais dans la réponse finale.
Série o d'OpenAI : comportement de l'API
Les modèles o1/o3/o4 d'OpenAI gèrent la réflexion en interne : par défaut, vous ne voyez pas les jetons de raisonnement. Vous pouvez observer le nombre de jetons de réflexion dans les métadonnées d'utilisation, mais pas leur contenu.
import openai
client = openai.OpenAI(api_key='sk-...')
# o3 — reasoning happens internally
response = client.chat.completions.create(
model='o3',
messages=[
{'role': 'user', 'content': 'Solve: A train leaves Chicago at 9am going 60mph. Another leaves NYC at 10am going 80mph. If the distance is 790 miles, when do they meet?'}
],
# reasoning_effort='high' # Optional: 'low', 'medium', 'high'
)
print(response.choices[0].message.content)
# Check how many tokens were used for thinking:
print('Input tokens:', response.usage.prompt_tokens)
print('Output tokens:', response.usage.completion_tokens)Réflexion prolongée de Claude : comportement de l'API
Claude d'Anthropic expose les jetons de réflexion prolongée via l'API. Vous pouvez transmettre et observer le processus de raisonnement du modèle en temps réel. Le contenu de la réflexion apparaît avant la réponse finale.
import anthropic
client = anthropic.Anthropic(api_key='sk-ant-...')
# Enable extended thinking
response = client.messages.create(
model='claude-opus-4-5',
max_tokens=16000,
thinking={
'type': 'enabled',
'budget_tokens': 10000 # Max tokens for thinking
},
messages=[{
'role': 'user',
'content': 'What is the 100th prime number?'
}]
)
# Response contains both thinking blocks and text blocks
for block in response.content:
if block.type == 'thinking':
print('THINKING:', block.thinking[:200], '...')
elif block.type == 'text':
print('ANSWER:', block.text)Transmettre les jetons de réflexion en continu
Vous pouvez transmettre la réflexion prolongée en temps réel et voir le raisonnement du modèle se dérouler. Cette possibilité est utile pour l'expérience utilisateur : afficher une animation de « réflexion » ou permettre aux utilisateurs avancés d'observer le processus de raisonnement.
import anthropic
client = anthropic.Anthropic(api_key='sk-ant-...')
def stream_with_thinking(question):
with client.messages.stream(
model='claude-opus-4-5',
max_tokens=16000,
thinking={'type': 'enabled', 'budget_tokens': 8000},
messages=[{'role': 'user', 'content': question}]
) as stream:
current_block_type = None
for event in stream:
# Track which block type we're in
if hasattr(event, 'type'):
if 'thinking' in str(event.type):
current_block_type = 'thinking'
elif 'text' in str(event.type):
current_block_type = 'text'
# Print text delta
if hasattr(event, 'delta') and hasattr(event.delta, 'text'):
prefix = '[THINK] ' if current_block_type == 'thinking' else '[ANS] '
print(prefix + event.delta.text, end='', flush=True)
stream_with_thinking('Explain why P != NP is unproven.')Ce qui se passe en interne : le brouillon
La réflexion interne du modèle lui sert de brouillon dans lequel il peut :
- explorer plusieurs approches avant de choisir
- effectuer des calculs et les vérifier
- repérer ses propres erreurs et revenir en arrière
- prendre en compte les cas limites
- planifier des solutions en plusieurs étapes
Cette délibération interne explique pourquoi les modèles de raisonnement surpassent largement les modèles standard en mathématiques difficiles, en programmation et en planification stratégique : ils effectuent pour ainsi dire une revue de la littérature avant d'écrire.
budget_tokens : Contrôler la profondeur du raisonnement
budget_tokens (Claude) ou reasoning_effort (OpenAI) contrôle la quantité de réflexion que le modèle effectue. Davantage de réflexion = une précision accrue pour les problèmes difficiles, mais aussi un coût et une latence plus élevés.
import anthropic
client = anthropic.Anthropic(api_key='sk-ant-...')
def ask_with_budget(question, budget):
r = client.messages.create(
model='claude-opus-4-5',
max_tokens=budget + 2048, # must exceed budget_tokens
thinking={'type': 'enabled', 'budget_tokens': budget},
messages=[{'role': 'user', 'content': question}]
)
thinking_tokens = sum(
len(b.thinking.split()) * 1.3 # rough estimate
for b in r.content if b.type == 'thinking'
)
answer = next(b.text for b in r.content if b.type == 'text')
return answer, int(thinking_tokens)
# Same hard question with different budgets
q = 'Prove that the square root of 2 is irrational.'
ans_small, tok_small = ask_with_budget(q, 1024)
ans_large, tok_large = ask_with_budget(q, 8000)
print(f'Small budget ({tok_small} thinking tokens): {ans_small[:100]}')
print(f'Large budget ({tok_large} thinking tokens): {ans_large[:100]}')Température et modèles de raisonnement
Les modèles de raisonnement se comportent différemment selon les réglages de température :
- Pour la gamme o d'OpenAI : la température est définie par défaut sur 1 et ne peut pas toujours être modifiée
- Pour le raisonnement étendu de Claude : la température est généralement définie sur 1 pendant le raisonnement
N'essayez pas d'utiliser la température pour contrôler le comportement des modèles de raisonnement : utilisez plutôt budget_tokens ou reasoning_effort.
import anthropic
client = anthropic.Anthropic(api_key='sk-ant-...')
# For Claude with extended thinking, temperature=1 is the default
# and best practice
response = client.messages.create(
model='claude-opus-4-5',
max_tokens=10000,
temperature=1, # Required to be 1 when extended thinking is enabled
thinking={
'type': 'enabled',
'budget_tokens': 5000
},
messages=[{
'role': 'user',
'content': 'Write a Python function to find all prime numbers up to N.'
}]
)
print(response.content[-1].text[:300])Repères de performance : là où le raisonnement fait la différence
Les modèles de raisonnement surpassent le plus nettement les modèles standard dans les domaines suivants :
- Mathématiques de compétition : AIME, AMC (o3 est proche du niveau d'un expert humain)
- Programmation complexe : programmation compétitive (Codeforces)
- Raisonnement scientifique : GPQA (sciences de niveau universitaire avancé)
- Logique en plusieurs étapes : problèmes nécessitant une déduction séquentielle
Pour les tâches simples (grammaire, résumé, questions-réponses factuelles), les modèles standard obtiennent d'aussi bons résultats pour un coût 10 à 100 fois inférieur.
La réalité de la latence
Les modèles de raisonnement sont lents. Un problème difficile avec un niveau élevé d'effort de raisonnement peut prendre de 30 à 60 secondes. Concevez votre interface utilisateur en conséquence :
- Affichez des indicateurs de progression « réflexion en cours… »
- Utilisez la diffusion en continu pour afficher les résultats partiels dès qu'ils sont disponibles
- N'utilisez pas de modèles de raisonnement pour les conversations en temps réel lorsque la latence est importante
- Précalculez les sorties des modèles de raisonnement pour les questions difficiles connues
import time
import anthropic
client = anthropic.Anthropic(api_key='sk-ant-...')
def timed_reasoning_call(question, budget):
start = time.time()
response = client.messages.create(
model='claude-opus-4-5',
max_tokens=budget + 2000,
thinking={'type': 'enabled', 'budget_tokens': budget},
messages=[{'role': 'user', 'content': question}]
)
elapsed = time.time() - start
answer = next(b.text for b in response.content if b.type == 'text')
print(f'Latency: {elapsed:.1f}s | Answer: {answer[:100]}')
return answer
# Hard problem — expect 20-45 seconds
timed_reasoning_call(
'Design a database schema for a multi-tenant SaaS billing system.',
budget=8000
)Modèles de raisonnement et instructions système
Les modèles de raisonnement répondent aux instructions système différemment des modèles standard. Comme ils délibèrent en interne avant de répondre, ils peuvent suivre plus fiablement des instructions complexes en plusieurs étapes dans les instructions système.
Cependant, des instructions système très longues et contraignantes peuvent entrer en conflit avec le raisonnement interne. Bonne pratique : gardez les instructions système concises pour les modèles de raisonnement — définissez le rôle et le format de sortie, puis laissez le raisonnement interne du modèle gérer la stratégie.
Vérification des connaissances : réflexion des modèles de raisonnement
Quelle est la différence fondamentale entre ce que fournit l'auteur de l'instruction et ce qui se produit en interne dans un modèle de raisonnement ?
Récapitulatif : en quoi les modèles de raisonnement diffèrent
Les modèles de raisonnement comme o1/o3 et Claude avec son raisonnement étendu exécutent une chaîne de raisonnement interne avant de répondre. L'auteur de l'instruction fournit un problème ; le modèle délibère en interne, explore différentes approches et se corrige, puis produit une réponse finale. Vous contrôlez la profondeur du raisonnement avec budget_tokens (Claude) ou reasoning_effort (OpenAI). Les modèles de raisonnement excellent en mathématiques complexes, en programmation et en logique en plusieurs étapes, mais ils coûtent 10 à 100 fois plus cher et sont 10 à 100 fois plus lents que les modèles standard. Utilisez la diffusion en continu et des indicateurs de progression pour gérer la latence dans votre interface utilisateur.
Questions Fréquemment Posées
La leçon « Différences entre les modèles de raisonnement » est-elle gratuite ?
Oui — le texte complet de « Différences entre les modèles de raisonnement » 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 « Différences entre les modèles de raisonnement » ?
Chaîne de pensée interne contre modèles standard : ce qui change pour l’auteur du prompt. 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 1 sur 4.
Combien de temps prend la leçon « Différences entre les modèles de raisonnement » ?
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