Was ist Temperature in LLMs?
Temperature als kreative Steuerung: 0 = deterministisch, 2 = chaotisch und alles dazwischen.
Was ist Temperature in LLMs? ist eine kostenlose AI Prompt Engineering-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des AI Prompt Engineering-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der AI Prompt Engineering-Kurs umfasst insgesamt 4 Lektionen.
Wie LLMs das nächste Token auswählen
In jedem Schritt gibt ein LLM eine Wahrscheinlichkeitsverteilung über alle Tokens seines Vokabulars aus (~50.000 Tokens bei GPT). Das Modell weist jedem Token einen Score namens Logit zu – eine rohe, nicht normalisierte Zahl. Je höher der Logit, desto wahrscheinlicher das Token.
Die Temperatur ist der Parameter, der steuert, wie diese rohen Logits vor dem Sampling in Wahrscheinlichkeiten umgewandelt werden.
Die Softmax-Funktion
Logits werden mithilfe der Softmax-Funktion in Wahrscheinlichkeiten umgewandelt. Softmax nimmt einen Vektor aus Logits entgegen und gibt eine Wahrscheinlichkeitsverteilung aus, deren Summe 1 ergibt.
Ein Beispiel mit einem kleinen Vokabular aus 4 Tokens:
import numpy as np
# Raw logits from the model
logits = np.array([2.0, 1.0, 0.5, -1.0]) # scores for 4 tokens
# Standard softmax (temperature = 1)
def softmax(logits, temperature=1.0):
scaled = logits / temperature
exp_scaled = np.exp(scaled - np.max(scaled)) # subtract max for numerical stability
return exp_scaled / exp_scaled.sum()
probs = softmax(logits, temperature=1.0)
print('Probabilities:', np.round(probs, 3))
# [0.567, 0.208, 0.129, 0.095]
# Token 0 is most likely at 56.7%Temperatur = 0: Greedy-Decoding
Wenn die Temperatur gegen 0 geht, kollabiert die Softmax-Verteilung: Das Token mit dem höchsten Logit erhält eine Wahrscheinlichkeit von etwa 1,0, während sich alle anderen 0 annähern. Das Modell wählt immer das einzelne wahrscheinlichste Token.
Dies wird als Greedy-Decoding bezeichnet. Es ist deterministisch – derselbe Prompt erzeugt immer dieselbe Ausgabe. Keine Zufälligkeit, keine Kreativität.
# Temperature = 0 (greedy)
probs_temp0 = softmax(logits, temperature=0.01) # near-zero
print('Probs at T=0.01:', np.round(probs_temp0, 4))
# [~1.0, ~0.0, ~0.0, ~0.0]
# In practice, temperature=0 is implemented as argmax:
def greedy_sample(logits):
return np.argmax(logits) # always returns the index of the highest logit
token_idx = greedy_sample(logits)
print(f'Selected token index: {token_idx}') # always 0Temperatur = 1: Standard-Sampling
Temperatur = 1 wendet Softmax ohne Skalierung an – die Wahrscheinlichkeitsverteilung spiegelt die natürliche Zuversicht des Modells wider. Das Modell sampelt entsprechend diesen Wahrscheinlichkeiten: Wahrscheinliche Tokens erscheinen häufig, unwahrscheinliche Tokens selten, aber gelegentlich.
Dies ist die Standardeinstellung für die meisten dialogorientierten Anwendungsfälle. Sie erzeugt abwechslungsreiche, natürliche Ausgaben, die dennoch schlüssig bleiben.
# Temperature = 1 (standard)
probs_temp1 = softmax(logits, temperature=1.0)
print('Probs at T=1.0:', np.round(probs_temp1, 3))
# [0.567, 0.208, 0.129, 0.095]
# Sampling from this distribution:
def sample_token(probs):
vocab = ['the', 'a', 'an', 'is']
return np.random.choice(vocab, p=probs)
# Run 10 times to see variation
for _ in range(10):
print(sample_token(probs_temp1), end=' ')
# Output varies each time, but 'the' appears most oftenTemperatur = 2: Chaotisches Sampling
Eine hohe Temperatur (> 1) flacht die Wahrscheinlichkeitsverteilung ab – alle Tokens werden annähernd gleich wahrscheinlich. Das Modell wird unberechenbar und oft inkohärent.
Temperaturen über 1,5 werden in der Praxis selten verwendet. Sie können kreative, unerwartete Ausgaben erzeugen, führen aber meist zu unsinnigen Ergebnissen.
# Temperature = 2 (chaotic)
probs_temp2 = softmax(logits, temperature=2.0)
print('Probs at T=2.0:', np.round(probs_temp2, 3))
# [0.385, 0.261, 0.211, 0.143]
# Much flatter — the 4th token (logit=-1.0) now has 14.3% chance
# (vs 9.5% at T=1.0)
# Visualization: compare distributions
for temp in [0.1, 0.5, 1.0, 1.5, 2.0]:
probs = softmax(logits, temperature=temp)
print(f'T={temp}: {np.round(probs, 3)}')Temperatur als Steuerung der Verteilungsschärfe
Konzeptionell steuert die Temperatur die Schärfe der Verteilung:
- Niedrige Temperatur (0,1–0,4): scharfer Gipfel – das Modell ist zuversichtlich und wählt sichere, häufige Tokens
- Mittlere Temperatur (0,6–1,0): natürliche Form – ausgewogenes Verhältnis zwischen Kreativität und Schlüssigkeit
- Hohe Temperatur (1,2–2,0): flache Verteilung – das Modell probiert frei unwahrscheinliche Tokens aus
Stellen Sie sich die Temperatur als Kreativitätsregler vor: niedrig = präzise, hoch = abenteuerlich.
import matplotlib
# Conceptual: what distribution shape looks like at different temps
temps = {'T=0.2 (sharp)': 0.2, 'T=1.0 (normal)': 1.0, 'T=2.0 (flat)': 2.0}
for label, temp in temps.items():
probs = softmax(logits, temp)
bar = '#' * int(probs[0] * 40)
print(f'{label}: top token = {probs[0]:.1%} |{bar}|')
# T=0.2: top token = 97.2% |########################################|
# T=1.0: top token = 56.7% |######################|
# T=2.0: top token = 38.5% |###############|Temperatur und Determinismus
Eine wichtige Feinheit: temperature = 0 macht das Sampling deterministisch. Bei temperature > 0 erzeugt jeder Durchlauf eine andere Ausgabe, da Sampling ein zufälliger Prozess ist. Die Verteilung bleibt gleich, aber das Sample variiert.
Für reproduzierbare Ausgaben in Tests setzen Sie temperature immer auf 0. Für die Produktion mit gewünschter Variation verwenden Sie einen Seed, sofern die API dies unterstützt.
import openai
client = openai.OpenAI(api_key='sk-...')
# Deterministic: temperature=0
resp1 = client.chat.completions.create(
model='gpt-4o',
messages=[{'role': 'user', 'content': 'What is the capital of France?'}],
temperature=0
)
resp2 = client.chat.completions.create(
model='gpt-4o',
messages=[{'role': 'user', 'content': 'What is the capital of France?'}],
temperature=0
)
print(resp1.choices[0].message.content == resp2.choices[0].message.content) # True (usually)Wie Temperatur und Top-p zusammenwirken
Temperatur und Top-p (Nucleus-Sampling) beeinflussen beide die Sampling-Verteilung, jedoch in unterschiedlichen Phasen:
- Temperatur: skaliert Logits vor Softmax und verändert dadurch die Form der gesamten Verteilung
- Top-p: beschränkt die Verteilung nach Softmax auf die obersten p-Wahrscheinlichkeitsanteile und sampelt nur aus der Menge der wahrscheinlichsten Tokens
Die gemeinsame Verwendung ermöglicht eine präzise Steuerung. Die übliche Empfehlung lautet: Verändern Sie immer nur einen Wert. Wenn Sie beide gleichzeitig ändern, lässt sich die Wirkung nur schwer vorhersagen.
# Using temperature with top_p in OpenAI API
resp = client.chat.completions.create(
model='gpt-4o',
messages=[{'role': 'user', 'content': 'Write a one-line haiku about code.'}],
temperature=0.9, # moderately diverse distribution
top_p=0.95 # sample from top 95% of probability mass
)Praktische Temperaturwerte nach Aufgabe
Schnellübersicht für gängige Aufgabentypen:
- Faktische Fragen und Antworten: 0 – muss korrekt sein, keine Variation erforderlich
- Codegenerierung: 0–0.2 – die Syntax muss korrekt sein
- Zusammenfassungen: 0.3–0.5 – etwas Variation ist akzeptabel
- Chat und Konversation: 0.7–0.9 – natürliche, abwechslungsreiche Antworten
- Kreatives Schreiben: 0.9–1.2 – Vielfalt ist erwünscht
- Brainstorming und Ideenfindung: 1.0–1.5 – unerwartete Optionen erkunden
TEMPERATURE_PRESETS = {
'factual_qa': 0.0,
'code_generation': 0.1,
'summarization': 0.4,
'chat': 0.8,
'creative_writing': 1.1,
'brainstorming': 1.3
}
def call_with_preset(task_type, prompt):
temp = TEMPERATURE_PRESETS.get(task_type, 0.7)
return client.chat.completions.create(
model='gpt-4o',
messages=[{'role': 'user', 'content': prompt}],
temperature=temp
)Temperatur in der API
Temperatur wird von allen wichtigen LLM-APIs unterstützt. Der gültige Bereich reicht bei OpenAI von 0–2 und bei Anthropic Claude von 0–1. Eine Überschreitung des Höchstwerts löst einen Fehler aus.
# OpenAI: temperature 0 to 2
client.chat.completions.create(
model='gpt-4o',
messages=[{'role': 'user', 'content': prompt}],
temperature=1.2 # Valid for OpenAI
)
# Anthropic Claude: temperature 0 to 1
import anthropic
claude = anthropic.Anthropic(api_key='sk-ant-...')
claude.messages.create(
model='claude-opus-4-5',
max_tokens=1024,
temperature=0.8, # Max is 1.0 for Claude
messages=[{'role': 'user', 'content': prompt}]
)Wenn Temperatur nicht ausreicht
Temperatur allein erzeugt nicht immer die gewünschte Vielfalt oder Präzision. Wenn temperature=0 weiterhin zu unterschiedlichen Ausgaben führt (bei einigen Modellen kann dies durch Gleitkomma-Nichtdeterminismus geschehen), verwenden Sie seed für echte Reproduzierbarkeit. Wenn eine hohe Temperatur unsinnige Ausgaben erzeugt, beschränken Sie das Vokabular stattdessen mit top-p oder top-k, anstatt die Temperatur weiter zu erhöhen.
# Seed for reproducibility (OpenAI API)
resp = client.chat.completions.create(
model='gpt-4o',
messages=[{'role': 'user', 'content': prompt}],
temperature=0,
seed=42 # Guarantees same output across calls on same model version
)
# Note: same output only guaranteed with same model version
# A model update can change outputs even with the same seedWissenscheck
Was geschieht mit der Wahrscheinlichkeitsverteilung über Tokens, wenn die Temperatur auf einen sehr hohen Wert (z. B. 2.0) gesetzt wird?
Zusammenfassung: Temperatur in LLMs
Temperatur steuert die Zufälligkeit des Token-Samplings, indem sie die Logits vor Softmax skaliert:
- T=0: Greedy – wählt immer das wahrscheinlichste Token, deterministisch
- T=1: Standard – sampelt entsprechend der natürlichen Wahrscheinlichkeitsverteilung
- T>1: chaotisch – flacht die Verteilung ab, mehr Zufälligkeit, weniger Kohärenz
Verwenden Sie eine niedrige Temperatur für faktische Aufgaben und Code, eine mittlere für Chat und eine hohe für kreative Aufgaben. Verändern Sie immer nur die Temperatur oder top-p, nicht beide gleichzeitig. In der nächsten Lektion geht es um Top-p-Nucleus-Sampling.
Häufig gestellte Fragen
Ist die Lektion „Was ist Temperature in LLMs?“ kostenlos?
Ja — der vollständige Text von „Was ist Temperature in LLMs?“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des AI Prompt Engineering-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der AI Prompt Engineering-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Was ist Temperature in LLMs?“?
Temperature als kreative Steuerung: 0 = deterministisch, 2 = chaotisch und alles dazwischen. Du übst AI Prompt Engineering mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um AI Prompt Engineering zu starten?
Keine Vorkenntnisse erforderlich. AI Prompt Engineering auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.
Wie lange dauert die Lektion „Was ist Temperature in LLMs?“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser AI Prompt Engineering-Lektion Code schreiben und ausführen?
Ja. Jede AI Prompt Engineering-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Was ist Temperature in LLMs?
- Top-p-Nucleus-Sampling
- Top-k-Sampling
- Parameter für Ihren Anwendungsfall auswählen