AI Prompt Engineering · Leçon

Échantillonnage par noyau avec top-p

Découvrez comment top-p limite l’échantillonnage à l’ensemble des tokens les plus probables.

Échantillonnage par noyau avec top-p est une leçon AI Prompt Engineering gratuite sur CoddyKit. Ceci est la leçon 2 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.

Qu’est-ce que l’échantillonnage top-p ?

L’échantillonnage top-p (également appelé échantillonnage par noyau) est une technique qui restreint l’échantillonnage à un sous-ensemble dynamique du vocabulaire. Au lieu d’échantillonner parmi tous les jetons, le modèle ne considère que le plus petit ensemble de jetons dont la probabilité cumulée est au moins égale à p.

Proposé dans l’article « Le curieux cas de la dégénérescence des textes neuronaux » (Holtzman et al., 2019), il surpasse la simple mise à l’échelle de la température pour produire des textes variés et cohérents.

Fonctionnement de top-p étape par étape

Algorithme :

Calculer les probabilités softmax sur l’ensemble du vocabulaire
Trier les jetons par probabilité, de la plus élevée à la plus faible
Parcourir la liste triée en cumulant les probabilités jusqu’à ce que la somme cumulée atteigne p
Cet ensemble de jetons constitue le noyau
Échantillonner uniquement à partir du noyau (renormaliser les probabilités pour que leur somme soit égale à 1)

import numpy as np

def top_p_sample(logits, p=0.9):
    probs = softmax(logits, temperature=1.0)

    # Sort by probability descending
    sorted_indices = np.argsort(probs)[::-1]
    sorted_probs = probs[sorted_indices]

    # Find nucleus: smallest set with cumulative prob >= p
    cumulative = np.cumsum(sorted_probs)
    nucleus_size = np.searchsorted(cumulative, p) + 1
    nucleus_indices = sorted_indices[:nucleus_size]
    nucleus_probs = sorted_probs[:nucleus_size]

    # Renormalize
    nucleus_probs = nucleus_probs / nucleus_probs.sum()

    # Sample
    chosen = np.random.choice(nucleus_indices, p=nucleus_probs)
    return chosen

token = top_p_sample(logits, p=0.9)

Le noyau dynamique

L’idée clé de top-p est que la taille du noyau est dynamique. Lorsque le modèle est très sûr de lui (un jeton domine avec une probabilité de 0.95), le noyau ne contient qu’un seul jeton. Lorsque le modèle est incertain (de nombreux jetons ont des probabilités similaires), le noyau s’agrandit pour inclure davantage de jetons.

Le mécanisme s’adapte ainsi automatiquement à la confiance du modèle — confiance élevée → vocabulaire réduit → sortie ciblée. Confiance faible → vocabulaire plus vaste → exploration accrue.

# High-confidence situation: model strongly prefers 'the'
high_confidence_logits = np.array([5.0, 1.0, 0.5, 0.1, -0.5])
hc_probs = softmax(high_confidence_logits)
print('High confidence probs:', np.round(hc_probs, 3))
# [0.974, 0.018, 0.011, 0.007, 0.004]
# Top-p=0.9 nucleus: just 1 token (cumulative after token 0 = 97.4% > 90%)

# Low-confidence situation: model unsure
low_confidence_logits = np.array([1.1, 1.0, 0.9, 0.8, 0.7])
lc_probs = softmax(low_confidence_logits)
print('Low confidence probs:', np.round(lc_probs, 3))
# [0.218, 0.208, 0.199, 0.190, 0.181]
# Top-p=0.9 nucleus: all 5 tokens (need all to reach 90%)

Top-p dans l’API OpenAI

Définissez top_p dans votre appel d’API. La plage valide est de 0.0 à 1.0. La valeur par défaut est 1.0 (vocabulaire complet, sans restriction du noyau).

OpenAI recommande que, si vous modifiez top_p, vous laissiez la température à 1.0, et inversement. Ajuster les deux simultanément rend le comportement effectif de l’échantillonnage difficile à prévoir.

import openai
client = openai.OpenAI(api_key='sk-...')

# Nucleus sampling: top 90% of probability mass
resp = client.chat.completions.create(
    model='gpt-4o',
    messages=[{'role': 'user', 'content': 'Tell me an interesting fact about the ocean.'}],
    temperature=1.0,   # leave temperature at default
    top_p=0.9          # sample from top 90% nucleus
)
print(resp.choices[0].message.content)

p=1.0 : échantillonnage sans restriction

Lorsque top_p=1.0, le noyau inclut tous les jetons — l’intégralité du vocabulaire. Cela équivaut à un échantillonnage fondé uniquement sur la température, sans restriction top-p. Chaque jeton, aussi improbable soit-il, a une probabilité non nulle d’être sélectionné.

Utilisez p=1.0 lorsque vous souhaitez une diversité maximale. Avec p=1.0, seule la température contrôle la forme de la distribution.

# p=1.0: all tokens in nucleus
resp_full = client.chat.completions.create(
    model='gpt-4o',
    messages=[{'role': 'user', 'content': 'Generate a creative story opening.'}],
    temperature=1.0,
    top_p=1.0  # no nucleus restriction
)

# p=0.5: very focused nucleus
resp_focused = client.chat.completions.create(
    model='gpt-4o',
    messages=[{'role': 'user', 'content': 'Generate a creative story opening.'}],
    temperature=1.0,
    top_p=0.5  # only top 50% probability mass
)

Compromis : top-p ou température

Les deux paramètres contrôlent la diversité de la sortie, mais de manière différente :

La température remodèle toute la distribution — la probabilité relative d’un jeton par rapport à toutes les autres change
Top-p tronque la distribution — un jeton est simplement exclu s’il se trouve en dehors du noyau, quelle que soit sa probabilité relative

Top-p évite le problème de l’échantillonnage dans la queue : avec une température élevée, des jetons extrêmement improbables (charabia, mots sans rapport) sont parfois échantillonnés. Top-p exclut entièrement ces jetons de la sélection.

# The tail problem with temperature alone
high_temp_logits = np.array([3.0, 2.0, 1.0, 0.0, -1.0, -5.0, -10.0])
probs_high_temp = softmax(high_temp_logits, temperature=2.0)
print('High temp probs:', np.round(probs_high_temp, 4))
# The last token (logit=-10) still has a small probability
# With many tokens in a real vocab, these rare tokens accumulate
# and occasionally get sampled, producing incoherent output

# Top-p=0.9 cuts these off entirely
# ensuring only tokens contributing to the top 90% are considered

Combiner la température et top-p

Lorsqu’on combine les deux paramètres, la température est appliquée en premier (elle remodèle la distribution), puis top-p est appliqué aux probabilités obtenues (pour les réduire au noyau).

Configurations courantes en production :

Écriture créative : température=1.0, top_p=0.95
Dialogue : température=0.8, top_p=0.9
Code : température=0.2, top_p=1.0 (top-p n’est pas restrictif à faible température)

def combined_sample(logits, temperature=1.0, top_p=0.9):
    # Step 1: apply temperature
    probs = softmax(logits, temperature=temperature)

    # Step 2: apply top-p nucleus
    sorted_idx = np.argsort(probs)[::-1]
    sorted_probs = probs[sorted_idx]
    cumulative = np.cumsum(sorted_probs)
    nucleus_size = np.searchsorted(cumulative, top_p) + 1
    nucleus_idx = sorted_idx[:nucleus_size]
    nucleus_probs = probs[nucleus_idx]
    nucleus_probs = nucleus_probs / nucleus_probs.sum()

    return np.random.choice(nucleus_idx, p=nucleus_probs)

Top-p et répétition

Des valeurs faibles de top-p peuvent provoquer des répétitions. Lorsque le noyau est très petit (par exemple, p=0.5), le modèle échantillonne à plusieurs reprises à partir d’un ensemble minuscule de jetons. La sortie devient répétitive et prévisible — l’inverse de l’effet créatif recherché.

Surveillez les répétitions : elles indiquent que top-p est peut-être réglé trop bas pour la tâche. Un diagnostic utile : si le modèle boucle sur les mêmes expressions, augmentez top-p ou la température.

def detect_repetition(text, window=20):
    words = text.split()
    if len(words) < window * 2:
        return False
    # Check if any window of words repeats within the text
    for i in range(len(words) - window):
        phrase = ' '.join(words[i:i + window])
        rest = ' '.join(words[i + window:])
        if phrase in rest:
            return True
    return False

response = call_llm(prompt)
if detect_repetition(response):
    print('Warning: repetition detected — consider increasing top_p or temperature')

Top-p ou top-k : aperçu

Top-p et top-k tronquent tous deux le vocabulaire avant l’échantillonnage, mais de manière différente :

Top-p : taille de noyau dynamique — s’agrandit lorsque le modèle est incertain et diminue lorsqu’il est sûr de lui
Top-k : taille de noyau fixe — considère toujours exactement k jetons, quelle que soit la confiance du modèle

Top-p est généralement préféré parce qu’il s’adapte à la confiance du modèle. Top-k est traité en détail dans la prochaine leçon.

# Top-k equivalent for comparison
def top_k_sample(logits, k=50):
    probs = softmax(logits)
    # Keep only top-k tokens
    top_k_indices = np.argsort(probs)[::-1][:k]
    top_k_probs = probs[top_k_indices]
    top_k_probs = top_k_probs / top_k_probs.sum()
    return np.random.choice(top_k_indices, p=top_k_probs)

# Key difference: k is always 50, regardless of model confidence
# Top-p nucleus size varies from 1 to thousands depending on confidence

Valeurs par défaut et situations justifiant leur modification

Valeurs par défaut de l’API : top_p = 1.0 (aucune restriction du noyau). Quand devriez-vous le modifier ?

Réduire top_p (0.7–0.9) : lorsque les sorties semblent incohérentes ou contiennent des mots dépourvus de sens — trop d’échantillonnage dans la queue
Le laisser à 1.0 : lorsque la température est déjà basse — à faible température, la distribution est déjà concentrée et top-p n’est de toute façon pas restrictif
Ne pas le réduire en dessous de 0.5 : cela provoque des répétitions et une perte de diversité

# Guidance: what to adjust based on symptoms
TROUBLESHOOTING = {
    'output is incoherent or contains random words': {
        'fix': 'lower top_p to 0.9 or 0.85',
        'or': 'lower temperature'
    },
    'output is repetitive and looping': {
        'fix': 'increase top_p or temperature',
        'also': 'try adding frequency_penalty or presence_penalty'
    },
    'output is too predictable and boring': {
        'fix': 'increase temperature to 0.9-1.2',
        'keep': 'top_p at 0.95'
    },
    'output needs to be deterministic': {
        'fix': 'set temperature=0, top_p=1.0'
    }
}

Top-p dans Claude d’Anthropic

L’API Claude d’Anthropic expose également top_p comme paramètre. Le comportement est identique : le modèle construit un noyau constitué du plus petit ensemble de jetons dont la probabilité cumulée atteint le seuil p, puis échantillonne à partir de ce noyau.

Combinez-le à la température pour un contrôle précis : utilisez la température pour façonner la distribution et top_p pour limiter les jetons pouvant être sélectionnés dans cette distribution.

import anthropic
claude = anthropic.Anthropic(api_key='sk-ant-...')

# Creative writing with nucleus sampling
message = claude.messages.create(
    model='claude-opus-4-5',
    max_tokens=256,
    temperature=1.0,
    top_p=0.95,
    messages=[{
        'role': 'user',
        'content': 'Write a short poem about the ocean.'
    }]
)
print(message.content[0].text)

Vérification des connaissances

Quel est le principal avantage de l’échantillonnage top-p (par noyau) par rapport à l’échantillonnage top-k ?

Récapitulatif : échantillonnage par noyau top-p

L’échantillonnage top-p construit un noyau dynamique — le plus petit ensemble de jetons couvrant au moins p de la probabilité totale :

p=1.0 : vocabulaire complet, aucune restriction
p=0.9 : les 90 % les plus probables de la masse de probabilité — réglage créatif courant
p=0.5 : très ciblé — risque de répétition

Le noyau s’agrandit lorsque le modèle est incertain et se contracte lorsqu’il est sûr de lui. Cela évite l’échantillonnage dans la queue (charabia produit par des jetons improbables) tout en préservant la diversité. Prochaine leçon : l’échantillonnage top-k et ses différences avec top-p.

Questions Fréquemment Posées

La leçon « Échantillonnage par noyau avec top-p » est-elle gratuite ?

Oui — le texte complet de « Échantillonnage par noyau avec top-p » 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 « Échantillonnage par noyau avec top-p » ?

Découvrez comment top-p limite l’échantillonnage à l’ensemble des tokens les plus probables. 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 2 sur 4.

Combien de temps prend la leçon « Échantillonnage par noyau avec top-p » ?

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

Qu’est-ce que la température dans les LLM ?
Échantillonnage par noyau avec top-p
Échantillonnage top-k
Choisir les paramètres selon votre cas d’usage

← Retour à AI Prompt Engineering