AI-promptengineering · Les

Top-p-nucleus sampling

Hoe top-p sampling beperkt tot de verzameling tokens met de hoogste waarschijnlijkheid.

Les 2 van 413 stappen

Top-p-nucleus sampling is een gratis AI-promptengineering-les op CoddyKit. Dit is les 2 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject AI-promptengineering. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus AI-promptengineering bevat in totaal 4 lessen.

Wat is top-p-sampling?

Top-p-sampling (ook wel nucleus sampling genoemd) is een techniek die de steekproeftrekking beperkt tot een dynamische deelverzameling van de woordenschat. In plaats van uit alle tokens te trekken, houdt het model alleen rekening met de kleinste verzameling tokens waarvan de cumulatieve waarschijnlijkheid ten minste p is.

Deze methode werd voorgesteld in het artikel 'Het merkwaardige geval van neurale tekstdegeneratie' (Holtzman et al., 2019) en presteert beter dan eenvoudige temperatuurschaling voor het genereren van gevarieerde maar samenhangende tekst.

Hoe top-p stap voor stap werkt

Algoritme:

Bereken softmax-waarschijnlijkheden voor de volledige woordenschat
Sorteer tokens op waarschijnlijkheid (hoogste eerst)
Loop de gesorteerde lijst af en tel de waarschijnlijkheden op totdat de cumulatieve som p bereikt
Deze verzameling tokens is de nucleus
Trek alleen uit de nucleus (normaliseer de waarschijnlijkheden opnieuw zodat de som 1 is)

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)

De dynamische nucleus

Het belangrijkste inzicht van top-p: de omvang van de nucleus is dynamisch. Wanneer het model veel vertrouwen heeft (één token domineert met een waarschijnlijkheid van 0.95), bevat de nucleus slechts 1 token. Wanneer het model onzeker is (veel tokens hebben een vergelijkbare waarschijnlijkheid), wordt de nucleus groter en bevat deze meer tokens.

Dit past zich automatisch aan de zekerheid van het model aan — grote zekerheid → kleine woordenschat → gerichte uitvoer. Geringe zekerheid → grotere woordenschat → meer verkenning.

# 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 in de OpenAI-API

Stel top_p in bij je API-aanroep. Het geldige bereik is 0.0–1.0. De standaardwaarde is 1.0 (volledige woordenschat, zonder nucleusbeperking).

OpenAI raadt aan: als je top_p wijzigt, laat je temperatuur op 1.0 staan, en omgekeerd. Als je beide gelijktijdig aanpast, is het effectieve steekproefgedrag moeilijk te voorspellen.

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: onbeperkte steekproeftrekking

Wanneer top_p=1.0 omvat de nucleus alle tokens — de volledige woordenschat. Dit is gelijk aan zuivere temperatuursteekproeftrekking zonder top-p-beperking. Elk token, hoe onwaarschijnlijk ook, heeft een kans groter dan nul om te worden geselecteerd.

Gebruik p=1.0 wanneer je maximale diversiteit wilt. Bij p=1.0 bepaalt alleen temperatuur de vorm van de verdeling.

# 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
)

Afweging: top-p versus temperatuur

Beide parameters bepalen de diversiteit van de uitvoer, maar op verschillende manieren:

Temperatuur vervormt de volledige verdeling — de relatieve waarschijnlijkheid van een token ten opzichte van alle andere verandert
Top-p beperkt de verdeling — een token wordt eenvoudig uitgesloten als het buiten de nucleus valt, ongeacht de relatieve waarschijnlijkheid ervan

Top-p voorkomt het probleem van steekproeftrekking uit de staart: bij een hoge temperatuur worden uiterst onwaarschijnlijke tokens (onbegrijpelijke tekst, ongerelateerde woorden) soms toch getrokken. Top-p sluit deze tokens volledig uit.

# 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

Temperatuur en top-p combineren

Wanneer je beide parameters combineert, wordt temperatuur eerst toegepast (de verdeling wordt vervormd) en vervolgens wordt top-p toegepast op de resulterende waarschijnlijkheden (deze worden beperkt tot de nucleus).

Veelgebruikte productieconfiguraties:

Creatief schrijven: temp=1.0, top_p=0.95
Chat: temp=0.8, top_p=0.9
Code: temp=0.2, top_p=1.0 (top-p beperkt niet bij een lage temperatuur)

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 en herhaling

Lage top-p-waarden kunnen herhaling veroorzaken. Wanneer de nucleus erg klein is (bijvoorbeeld p=0.5), trekt het model herhaaldelijk steekproeven uit een zeer kleine verzameling tokens. De uitvoer wordt repetitief en voorspelbaar — het tegenovergestelde van het bedoelde creatieve effect.

Let op herhaling als signaal dat top-p te laag is ingesteld voor de taak. Een nuttige controle: als het model dezelfde zinnen blijft herhalen, verhoog dan top-p of de temperatuur.

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 versus top-k: een voorproefje

Top-p en top-k beperken beide de woordenschat vóór het trekken van steekproeven, maar op verschillende manieren:

Top-p: dynamische omvang van de nucleus — wordt groter wanneer het model onzeker is en kleiner wanneer het vertrouwen heeft
Top-k: vaste omvang van de nucleus — houdt altijd precies k tokens in overweging, ongeacht de zekerheid

Over het algemeen heeft top-p de voorkeur, omdat het zich aanpast aan de zekerheid van het model. Top-k wordt uitvoerig behandeld in de volgende les.

# 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

Standaardwaarden en wanneer je ze wijzigt

Standaardwaarden van API's: top_p = 1.0 (geen nucleusbeperking). Wanneer moet je dit wijzigen?

Verlaag top_p (0.7–0.9): wanneer de uitvoer onsamenhangend aanvoelt of onzinnige woorden bevat — te veel steekproeftrekking uit de staart
Laat de waarde op 1.0 staan: wanneer de temperatuur al laag is — bij een lage temperatuur is de verdeling al scherp en beperkt top-p toch niet
Verlaag de waarde niet tot onder 0.5: dit veroorzaakt herhaling en verlies van diversiteit

# 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 in Anthropic Claude

De Claude-API van Anthropic biedt top_p ook als parameter. Het gedrag is identiek: het model stelt een nucleus samen van de kleinste verzameling tokens waarvan de cumulatieve waarschijnlijkheid de drempel p bereikt, en trekt vervolgens alleen uit die nucleus.

Combineer dit met temperatuur voor nauwkeurige controle: gebruik temperatuur om de verdeling vorm te geven en top_p om te begrenzen welke tokens uit die verdeling kunnen worden geselecteerd.

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)

Kennistoets

Wat is het belangrijkste voordeel van top-p-sampling (nucleus sampling) ten opzichte van top-k-sampling?

Beantwoord dit in de interactieve les

Samenvatting: nucleus-sampling met top-p

Top-p-sampling bouwt een dynamische nucleus — de kleinste verzameling tokens die ten minste p van de totale waarschijnlijkheid omvat:

p=1.0: volledige woordenschat, geen beperking
p=0.9: de bovenste 90% van de waarschijnlijkheidsmassa — een typische instelling voor creatief werk
p=0.5: zeer gericht — risico op herhaling

De nucleus wordt groter wanneer het model onzeker is en kleiner wanneer het vertrouwen heeft. Zo wordt steekproeftrekking uit de staart voorkomen (onbegrijpelijke tekst uit onwaarschijnlijke tokens), terwijl de diversiteit behouden blijft. Volgende les: top-k-sampling en het verschil met top-p.

Gratis beginnen

Leer AI-promptengineering met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 53
Lessen: 199

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Top-p-nucleus sampling” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad AI-promptengineering, waaronder “Top-p-nucleus sampling”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus AI-promptengineering bevat in totaal 4 lessen.

Wat leer ik in “Top-p-nucleus sampling”?

Hoe top-p sampling beperkt tot de verzameling tokens met de hoogste waarschijnlijkheid. Je oefent met AI-promptengineering door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met AI-promptengineering te beginnen?

Ervaring vooraf is niet nodig. AI-promptengineering op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.

Hoe lang duurt de les “Top-p-nucleus sampling”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over AI-promptengineering?

Ja. Elke les over AI-promptengineering bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar AI-promptengineering