Prompts avec raisonnement explicite
Obtenir un raisonnement étape par étape.
Prompts avec raisonnement explicite 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.
Le raisonnement comme budget de jetons
Le chaînage de raisonnement (CoT) dans les invites amène le modèle à produire des étapes de raisonnement intermédiaires avant la réponse finale (answer). L’idée essentielle est la suivante : les transformeurs effectuent une quantité fixe de calcul pour chaque jeton. Autoriser le modèle à produire des jetons de raisonnement lui accorde donc effectivement davantage de calcul séquentiel pour parvenir à la réponse.
Forcer une réponse immédiate plafonne le calcul disponible pour un problème difficile ; le CoT supprime cette limite en répartissant le calcul sur les jetons générés.
# Direct: model must compute everything before the first token
DIRECT = 'Q: ' + q + '\nA:'
# CoT: model can use tokens as scratch space
COT = 'Q: ' + q + '\nA: Let us reason step by step.'CoT sans exemple
La célèbre phrase déclencheuse « Réfléchissons étape par étape » (Kojima et al., 2022) suscite un raisonnement sans exemples. Elle fonctionne parce que les modèles ajustés par instruction ont intégré le schéma selon lequel cette phrase précède une solution détaillée.
Le CoT sans exemple est peu coûteux et étonnamment efficace, mais la qualité de son raisonnement est moins contrôlable que celle d’un CoT à quelques exemples soigneusement sélectionnés.
def zero_shot_cot(question):
stage1 = llm('Q: ' + question + '\nA: Let us think step by step.')
# Extract the final answer in a second, constrained call
stage2 = llm(stage1 + '\nTherefore, the final answer is:')
return parse_answer(stage2)CoT à quelques exemples
Le CoT à quelques exemples (Wei et al., 2022) fournit des exemples qui incluent la trace de raisonnement, et pas seulement la réponse (answer). Cela enseigne à la fois comment raisonner et le format attendu, ce qui produit des chaînes plus fiables et plus cohérentes qu’en mode sans exemple.
Sélectionnez soigneusement des exemples dont le style, le niveau de détail et la longueur du raisonnement correspondent à ce que vous souhaitez faire reproduire. Un raisonnement incohérent dans les exemples produit des chaînes incohérentes.
FS_COT = (
'Q: Roger has 5 balls, buys 2 cans of 3. How many balls?\n'
'A: 5 + 2*3 = 5 + 6 = 11. The answer is 11.\n\n'
'Q: ' + question + '\nA:'
)Séparer le raisonnement de la réponse
Rendez toujours la réponse finale (answer) extractible par une machine : terminez la chaîne par un marqueur fixe (par exemple answer: X ou un champ JSON). L’analyse de chaînes en texte libre est fragile.
Pour les produits destinés aux utilisateurs, vous pouvez masquer la chaîne et n’afficher que la réponse analysée, en conservant le raisonnement comme brouillon interne.
import re
def extract(chain):
m = re.search(r'[Tt]he answer is\s*(.+?)[.\n]', chain)
if not m:
raise ValueError('no answer marker found')
return m.group(1).strip()La fidélité n’est pas garantie
Une réserve essentielle : la chaîne verbalisée peut ne pas refléter le véritable calcul du modèle. Des études montrent que les modèles peuvent produire un raisonnement plausible qui justifie a posteriori une réponse (answer) dictée par des biais cachés, comme la position d’une option.
Ne considérez pas le CoT comme une explication fidèle ni comme une piste d’audit. Il améliore l’exactitude dans de nombreuses tâches, mais ne révèle pas le mécanisme réel du modèle.
# Faithfulness probe: perturb an irrelevant cue (e.g., always make
# option A correct in the few-shot). If the chain still 'justifies'
# choosing A, the stated reasoning is unfaithful to the real cause.Réglages du décodage pour le CoT
Pour obtenir une chaîne déterministe unique, une faible température réduit la variance. Cependant, le CoT s’associe très bien à l’échantillonnage : à température modérée, vous pouvez produire plusieurs chaînes diversifiées et les agréger (ce qui est abordé dans la cohérence interne).
Évitez le décodage glouton lorsque vous souhaitez échantillonner plusieurs chemins : le mode glouton supprime la diversité et empêche l’agrégation.
single = llm(COT, temperature=0.0) # one stable chain
paths = [llm(COT, temperature=0.7) for _ in range(10)] # diverseRaisonnement structuré et tabulaire
Pour les problèmes complexes, imposez une structure à la chaîne : étapes numérotées, tableau d’état ou séparation entre planification et exécution. La structure réduit les étapes omises et rend l’état intermédiaire vérifiable.
Les approches assistées par programme vont plus loin en produisant du code exécutable comme raisonnement et en déléguant l’arithmétique à un interpréteur, ce qui élimine toute catégorie (class) d’erreurs de calcul.
PAL = (
'Solve by writing Python. Q: ' + q + '\n'
'A:\ndef solve():\n'
' # the model writes code here, then we exec() it\n'
)
# Offload arithmetic to a deterministic interpreterLongueur, coût et latence
Le CoT multiplie les jetons de sortie (output), ce qui augmente le coût et la latence. Pour les éléments faciles, ce surcoût n’apporte rien ; pour les éléments difficiles, il est essentiel. Une approche pragmatique est le raisonnement adaptatif (adaptive) : ne déclenchez le CoT que lorsqu’une estimation peu coûteuse de la difficulté ou une réponse directe peu fiable le justifie.
Avec les modèles de raisonnement qui intègrent une réflexion, vous contrôlez plutôt un budget d’effort de raisonnement que vous ne demandez vous-même la chaîne.
def adaptive(question):
direct = llm('Q: ' + question + '\nA (answer only):', temperature=0)
if confidence(direct) > 0.85:
return direct
return zero_shot_cot(question) # escalate to reasoning only if neededLe CoT sur les modèles conçus pour le raisonnement
Les modèles de raisonnement modernes effectuent automatiquement une délibération interne prolongée. Les saturer d’instructions détaillées telles que « Réfléchissons étape par étape » peut être redondant, voire contre-productif, car cela perturbe leur processus de réflexion appris.
Pour ces modèles, privilégiez des énoncés de tâche concis et des exigences explicites concernant le format de réponse, puis réglez le paramètre d’effort de raisonnement au lieu de concevoir manuellement des chaînes.
# Reasoning-native model: let it think, just constrain the output
resp = reasoning_model(
prompt=question,
reasoning_effort='medium',
output_format='Final answer on the last line as: ANSWER=<x>'
)Quand CoT produit l’effet inverse
CoT peut nuire dans les tâches où la délibération prend le pas sur une intuition correcte, pour la simple reconnaissance de motifs, ou lorsque la verbalisation introduit des erreurs que le modèle n’aurait pas commises implicitement. Elle élargit aussi la surface d’attaque pour les injections d’instructions à l’intérieur de longues chaînes.
Comparez CoT à une réponse directe pour chaque tâche ; ne supposez jamais que les instructions de raisonnement sont universellement bénéfiques.
def should_use_cot(task_acc_cot, task_acc_direct, cot_cost_mult):
gain = task_acc_cot - task_acc_direct
# Only adopt CoT if accuracy gain justifies the token multiplier
return gain > MIN_GAIN and gain / cot_cost_mult > MIN_EFFICIENCYDéployer CoT en production
CoT en production : sélectionnez soigneusement des exemples cohérents (ou appuyez-vous sur le raisonnement natif du modèle), imposez un marqueur de réponse analysable, échantillonnez plusieurs chaînes pour les éléments difficiles, validez l’arithmétique par exécution de code lorsque c’est possible et conditionnez le raisonnement à une estimation de difficulté afin de maîtriser les coûts.
Consignez les chaînes pour l’analyse hors ligne, mais ne les présentez jamais comme des explications de référence.
def production_solve(q):
if easy(q):
return extract(llm(DIRECT_PROMPT.format(q=q), temperature=0))
chains = [llm(FS_COT.format(q=q), temperature=0.7) for _ in range(8)]
return majority_vote([extract(c) for c in chains])Vérification rapide
Réfléchissez aux raisons pour lesquelles CoT est utile et aux situations où il ne l’est pas.
Récapitulatif
Points clés à retenir :
- CoT échange des jetons supplémentaires contre du calcul séquentiel supplémentaire ; il aide pour les tâches en plusieurs étapes, mais pas pour les tâches triviales.
- CoT sans exemple utilise une phrase déclencheuse ; CoT avec quelques exemples fournit des exemples cohérents de raisonnement.
- Terminez toujours par un marqueur de réponse extractible automatiquement ; les chaînes ne constituent pas des explications fidèles.
- Échantillonnez plusieurs chaînes pour les éléments difficiles, déléguez l’arithmétique au code et conditionnez CoT à la difficulté.
- Avec les modèles nativement capables de raisonner, préférez des instructions concises accompagnées d’un budget d’effort de raisonnement à de longues consignes décrivant la chaîne de raisonnement.
Questions Fréquemment Posées
La leçon « Prompts avec raisonnement explicite » est-elle gratuite ?
Oui — le texte complet de « Prompts avec raisonnement explicite » 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 « Prompts avec raisonnement explicite » ?
Obtenir un raisonnement étape par étape. 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 « Prompts avec raisonnement explicite » ?
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
- Prompts avec raisonnement explicite
- Échantillonnage par auto-cohérence
- Explorer les arbres de pensée
- Quand les prompts de raisonnement sont utiles