AI Prompt Engineering · Leçon

Comment l’IA génère des réponses

Prédiction des jetons, probabilités et raisons pour lesquelles l’IA ne « pense » pas comme les humains.

Comment l’IA génère des réponses est une leçon AI Prompt Engineering gratuite sur CoddyKit. Ceci est la leçon 3 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 texte comme problème de probabilité

À la base, un modèle linguistique ne fait qu'une seule chose : prédire le jeton suivant à partir de tous les jetons qui le précèdent.

Un jeton est une petite unité de texte, correspondant approximativement à un mot ou à un fragment de mot. Le modèle attribue une probabilité à chaque jeton de son vocabulaire et en choisit un. Il répète ensuite le processus, jeton après jeton, jusqu'à générer une réponse complète.

Qu'est-ce qu'un jeton ?

Les jetons sont les atomes du traitement de texte par les LLM. Le texte anglais est approximativement découpé en jetons ainsi :

Mots courants → 1 jeton chacun (the, run)
Mots moins courants → divisés en 2 ou 3 jetons (running → run + ning)
La ponctuation et les espaces → souvent leurs propres jetons

Les modèles comme GPT-4o et Claude utilisent des tokeniseurs qui gèrent plus de 100 k entrées de vocabulaire, y compris des sous-mots dans de nombreuses langues.

import tiktoken

encoding = tiktoken.encoding_for_model('gpt-4o')

sentence = 'The temperature parameter controls randomness in token selection.'
tokens = encoding.encode(sentence)
token_strings = [encoding.decode([t]) for t in tokens]

print(f'Sentence: {sentence}')
print(f'Token count: {len(tokens)}')
print(f'Tokens: {token_strings}')

Génération autorégressive

La génération est autorégressive : chaque nouveau jeton est ajouté à l'entrée avant de prédire le suivant.

Lorsqu'il génère « Le ciel est bleu », le modèle :

Voit « Le » → prédit « ciel »
Voit « Le ciel » → prédit « est »
Voit « Le ciel est » → prédit « bleu »
Voit « Le ciel est bleu » → prédit la fin de la séquence

C'est pourquoi la génération ralentit pour les sorties très longues : chaque jeton nécessite une passe avant complète.

# Simulated autoregressive token-by-token output via streaming
import openai

client = openai.OpenAI(api_key='sk-your-key-here')

stream = client.chat.completions.create(
    model='gpt-4o',
    stream=True,     # receive tokens as they are generated
    messages=[{'role': 'user', 'content': 'Name five planets in our solar system.'}]
)

print('Tokens arriving one by one:')
for chunk in stream:
    delta = chunk.choices[0].delta.content
    if delta:
        print(delta, end='', flush=True)
print()  # newline at end

Température : contrôler le hasard

La température est un nombre compris entre 0 et 2 qui redimensionne la distribution de probabilités avant l'échantillonnage :

Température 0 : toujours choisir le jeton le plus probable — déterministe et répétitif
Température 1 : échantillonner selon les probabilités brutes — équilibre
Température 2 : aplatir les probabilités — très aléatoire, parfois incohérent

Utilisez une température basse pour les tâches factuelles et une température plus élevée pour les travaux créatifs.

import openai

client = openai.OpenAI(api_key='sk-your-key-here')

prompt = 'Continue this sentence with one word: The ocean is'

for temp in [0.0, 0.7, 1.5]:
    response = client.chat.completions.create(
        model='gpt-4o',
        temperature=temp,
        max_tokens=5,
        messages=[{'role': 'user', 'content': prompt}]
    )
    word = response.choices[0].message.content.strip()
    print(f'Temperature {temp}: "{word}"')

Pourquoi les réponses varient d'une exécution à l'autre

Même avec la même invite, deux exécutions du même modèle peuvent produire des sorties différentes. Cela se produit parce que :

L'échantillonnage est probabiliste : le modèle tire ses choix d'une distribution, et non d'une table de correspondance
De petites différences numériques dans les calculs en virgule flottante peuvent se propager
Le parallélisme matériel introduit du non-déterminisme

Définissez temperature=0 et seed (si cette option est prise en charge) pour maximiser la reproductibilité.

import openai

client = openai.OpenAI(api_key='sk-your-key-here')

prompt = 'Give me a one-word color that feels calm.'

for run in range(3):
    response = client.chat.completions.create(
        model='gpt-4o',
        temperature=1.0,   # randomness ON
        max_tokens=5,
        messages=[{'role': 'user', 'content': prompt}]
    )
    print(f'Run {run + 1}: {response.choices[0].message.content.strip()}')

# For reproducible outputs use seed + temperature=0
response = client.chat.completions.create(
    model='gpt-4o',
    temperature=0,
    seed=42,
    max_tokens=5,
    messages=[{'role': 'user', 'content': prompt}]
)
print(f'Deterministic: {response.choices[0].message.content.strip()}')

Échantillonnage par noyau

L'échantillonnage par noyau est une autre manière de contrôler le hasard. Au lieu de redimensionner toutes les probabilités, il limite l'échantillonnage au plus petit ensemble de jetons dont la probabilité cumulée dépasse p.

top_p=0.1 : uniquement les jetons les mieux classés (conservateur)
top_p=0.9 : ensemble plus large (créatif)
top_p=1.0 : tous les jetons (distribution complète)

En pratique, la plupart des équipes ajustent la température et laissent l'échantillonnage par noyau à 1,0.

import openai

client = openai.OpenAI(api_key='sk-your-key-here')

# Conservative generation: top_p=0.1 restricts to high-confidence tokens
response_conservative = client.chat.completions.create(
    model='gpt-4o',
    top_p=0.1,
    max_tokens=30,
    messages=[{'role': 'user', 'content': 'What is the capital of Japan?'}]
)

# Creative generation: top_p=0.95 allows broader token pool
response_creative = client.chat.completions.create(
    model='gpt-4o',
    top_p=0.95,
    max_tokens=30,
    messages=[{'role': 'user', 'content': 'Write a poetic one-liner about the moon.'}]
)

print('Conservative:', response_conservative.choices[0].message.content)
print('Creative:    ', response_creative.choices[0].message.content)

Pas de véritable compréhension — appariement de motifs

Les LLM ne comprennent pas le langage comme les humains. Ce sont des systèmes d’appariement de motifs extrêmement sophistiqués, entraînés sur d’immenses corpus de textes.

Lorsque le modèle répond à la question « Qu’est-ce que la photosynthèse ? », il ne récupère pas un fait mémorisé : il génère la suite de jetons qui, statistiquement, suit le schéma de la question, parce qu’il a vu des millions de documents similaires pendant son entraînement.

# Demonstration: the model can produce plausible-sounding but wrong answers
import anthropic

client = anthropic.Anthropic(api_key='sk-ant-your-key-here')

# Asking about something nonsensical — model may still try to answer
response = client.messages.create(
    model='claude-opus-4-5',
    max_tokens=128,
    messages=[{
        'role': 'user',
        'content': (
            'What is the boiling point of happiness in degrees Celsius? '
            'Please just say "I cannot answer this" if the question makes no sense.'
        )
    }]
)
print(response.content[0].text)

Entraînement et inférence

Les « connaissances » du modèle ont été figées pendant son entraînement sur un vaste corpus de textes. Lors de l’inférence (lorsque vous envoyez une instruction), le modèle génère du texte à partir de ces connaissances figées : il n’apprend pas et ne fait pas de recherche sur Internet.

Cela signifie qu’il ne peut pas connaître les événements survenus après la date de coupure de son entraînement, accéder à des adresses web ni vérifier si un fait a changé depuis son entraînement.

import anthropic

client = anthropic.Anthropic(api_key='sk-ant-your-key-here')

# Asking the model about its own knowledge cutoff
response = client.messages.create(
    model='claude-opus-4-5',
    max_tokens=128,
    messages=[{
        'role': 'user',
        'content': (
            'What is your knowledge cutoff date? '
            'And can you access the internet right now to look up today\'s news?'
        )
    }]
)
print(response.content[0].text)

Ce qui se passe lors d’une propagation avant

À un niveau général, chaque prédiction de jeton implique :

La conversion de tous les jetons d’entrée en représentations vectorielles numériques
Leur passage à travers de nombreuses couches de transformateur (attention + propagation avant)
La production d’une distribution de probabilités sur l’ensemble du vocabulaire
L’échantillonnage d’un jeton à partir de cette distribution

Les modèles modernes possèdent des milliards de paramètres qui façonnent cette transformation — tous appris pendant l’entraînement à partir de textes humains.

# You can inspect logprobs (token probabilities) to see the model's confidence
import openai

client = openai.OpenAI(api_key='sk-your-key-here')

response = client.chat.completions.create(
    model='gpt-4o',
    max_tokens=5,
    logprobs=True,
    top_logprobs=3,
    messages=[{'role': 'user', 'content': 'The opposite of hot is'}]
)

for token_info in response.choices[0].logprobs.content:
    print(f'Chosen token: "{token_info.token}"')
    for alt in token_info.top_logprobs:
        import math
        prob = round(math.exp(alt.logprob) * 100, 1)
        print(f'  Option "{alt.token}": {prob}% probability')

Séquences d’arrêt

Les séquences d’arrêt indiquent au modèle de mettre fin à la génération lorsqu’il produit une chaîne spécifique. Elles sont utiles pour :

Empêcher le modèle de générer plus d’une réponse dans une liste
S’arrêter sur un délimiteur comme ### ou ---END---
Imposer des sorties sur une seule ligne

Sans séquence d’arrêt, le modèle génère du texte jusqu’à atteindre max_tokens ou à prédire un jeton de fin de séquence.

import openai

client = openai.OpenAI(api_key='sk-your-key-here')

# Stop after the first item in a numbered list
response = client.chat.completions.create(
    model='gpt-4o',
    max_tokens=64,
    stop=['2.'],   # halt as soon as '2.' appears
    messages=[{
        'role': 'user',
        'content': 'List 5 programming languages, numbered 1 through 5.'
    }]
)
print(response.choices[0].message.content)
print('Stop reason:', response.choices[0].finish_reason)

Conséquences pratiques pour la rédaction d’instructions

Comprendre les mécanismes de génération vous aide à rédiger de meilleures instructions :

Utilisez une température de 0 pour les tâches nécessitant une sortie cohérente et factuelle
Utilisez une température de 0,7 à 1,0 pour la rédaction créative
Vérifiez les faits : le modèle génère un texte plausible, et non une vérité garantie
Utilisez des séquences d’arrêt pour contrôler précisément la longueur de la sortie
Instructions courtes → sortie plus créative, mais moins contrôlée
Instructions détaillées → sortie plus cadrée et ciblée

import anthropic

client = anthropic.Anthropic(api_key='sk-ant-your-key-here')

# Low temperature for factual classification
fact_response = client.messages.create(
    model='claude-opus-4-5',
    max_tokens=8,
    temperature=0,   # deterministic
    messages=[{'role': 'user', 'content': 'Is Paris the capital of France? Answer YES or NO only.'}]
)
print('Factual (temp=0):', fact_response.content[0].text.strip())

# Higher temperature for creative tasks
creative_response = client.messages.create(
    model='claude-opus-4-5',
    max_tokens=64,
    temperature=1.0,
    messages=[{'role': 'user', 'content': 'Write a surprising one-line poem about code.'}]
)
print('Creative (temp=1):', creative_response.content[0].text.strip())

Vérification des connaissances

Vous avez appris comment les LLM génèrent du texte, jeton par jeton. Vérifions votre compréhension de la température.

Un développeur construit un robot conversationnel d’assistance à la clientèle qui doit fournir des réponses cohérentes et exactes aux questions de facturation. Quel réglage de température est le plus approprié ?

Comment l’IA génère des réponses — récapitulatif

Vous comprenez maintenant les mécanismes qui se cachent derrière chaque réponse de l’IA :

Les modèles prédisent le jeton suivant un à la fois — génération autorégressive
La température contrôle la quantité d’aléatoire injectée dans la sélection des jetons
Le paramètre de probabilité cumulative restreint l’échantillonnage à un noyau de jetons à forte probabilité
Le modèle ne comprend pas : il apparie des motifs à une échelle immense
Les connaissances sont figées lors de l’entraînement : pas de données en temps réel ni d’accès à Internet
Les séquences d’arrêt vous permettent de contrôler exactement où la sortie se termine

Questions Fréquemment Posées

La leçon « Comment l’IA génère des réponses » est-elle gratuite ?

Oui — le texte complet de « Comment l’IA génère des réponses » 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 « Comment l’IA génère des réponses » ?

Prédiction des jetons, probabilités et raisons pour lesquelles l’IA ne « pense » pas comme les humains. 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 3 sur 4.

Combien de temps prend la leçon « Comment l’IA génère des réponses » ?

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

← Retour à AI Prompt Engineering