AI Prompt Engineering · Lekcja

Czym jest temperatura w LLM-ach

Temperatura jako kontrola kreatywności: 0 = deterministycznie, 2 = chaotycznie, a pomiędzy nimi cała skala.

Czym jest temperatura w LLM-ach to bezpłatna lekcja AI Prompt Engineering na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej AI Prompt Engineering, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs AI Prompt Engineering zawiera 4 lekcji w sumie.

Jak LLM wybiera kolejny token

Na każdym etapie LLM generuje rozkład prawdopodobieństwa dla wszystkich tokenów ze swojego słownika (około 50 000 tokenów dla GPT). Model przypisuje każdemu tokenowi wynik nazywany logitem — surową, nienormalizowaną liczbą. Im wyższy logit, tym bardziej prawdopodobny token.

Temperatura to parametr sterujący sposobem przekształcania tych surowych logitów w prawdopodobieństwa przed próbkowaniem.

Funkcja softmax

Logity są przekształcane w prawdopodobieństwa za pomocą funkcji softmax. Funkcja softmax przyjmuje wektor logitów i zwraca rozkład prawdopodobieństwa, którego suma wynosi 1.

Przykład dla małego słownika zawierającego 4 tokeny:

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%

Temperatura = 0: dekodowanie zachłanne

Gdy temperatura zbliża się do 0, rozkład softmax ulega skupieniu: token o najwyższym logitcie otrzymuje prawdopodobieństwo około 1,0, a prawdopodobieństwa wszystkich pozostałych tokenów zbliżają się do 0. Model zawsze wybiera pojedynczy najbardziej prawdopodobny token.

Nazywa się to dekodowaniem zachłannym. Jest deterministyczne — ten sam prompt zawsze daje ten sam wynik. Zero losowości, zero kreatywności.

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

Temperatura = 1: standardowe próbkowanie

Temperatura = 1 oznacza zastosowanie funkcji softmax bez skalowania — rozkład prawdopodobieństwa odzwierciedla naturalną pewność modelu. Model próbuje dobierać tokeny zgodnie z tymi prawdopodobieństwami: prawdopodobne tokeny pojawiają się często, a mało prawdopodobne — rzadko, choć czasami również są wybierane.

To ustawienie domyślne w większości konwersacyjnych zastosowań. Zapewnia zróżnicowane, naturalne wypowiedzi, które nadal pozostają spójne.

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

Temperatura = 2: chaotyczne próbkowanie

Wysoka temperatura (> 1) spłaszcza rozkład prawdopodobieństwa — wszystkie tokeny stają się bardziej zbliżone pod względem prawdopodobieństwa. Model staje się nieprzewidywalny, a jego wypowiedzi często tracą spójność.

Temperatura > 1,5 jest rzadko stosowana w praktyce. Może prowadzić do kreatywnych i nieoczekiwanych wyników, ale zwykle generuje nonsens.

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

Temperatura jako regulator ostrości

W ujęciu koncepcyjnym temperatura steruje ostrością rozkładu:

Niska temperatura (0,1–0,4): wyraźny szczyt — model jest pewny siebie i wybiera bezpieczne, typowe tokeny
Średnia temperatura (0,6–1,0): naturalny kształt — równowaga między kreatywnością a spójnością
Wysoka temperatura (1,2–2,0): płaski rozkład — model swobodnie wybiera mało prawdopodobne tokeny

Można myśleć o niej jak o pokrętle kreatywności: niska wartość oznacza precyzję, a wysoka — skłonność do eksperymentowania.

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

Temperatura i determinizm

Ważne doprecyzowanie: temperatura = 0 sprawia, że próbkowanie jest deterministyczne. Dla temperatury > 0 każdy przebieg daje inny wynik, ponieważ próbkowanie jest procesem losowym. Rozkład pozostaje stały, ale próbka się zmienia.

Aby uzyskać powtarzalne wyniki w testach, należy zawsze ustawić temperaturę = 0. W środowisku produkcyjnym, gdy potrzebna jest zmienność, należy użyć ziarna, jeśli API je obsługuje.

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)

Jak temperatura współdziała z top-p

Temperatura i top-p (próbkowanie jądrowe) kształtują rozkład próbkowania, ale na różnych etapach:

Temperatura: skaluje wartości logits przed zastosowaniem softmaxu — zmienia kształt pełnego rozkładu
Top-p: ogranicza rozkład do tokenów obejmujących p największej masy prawdopodobieństwa po zastosowaniu softmaxu — próbkowanie odbywa się wyłącznie ze zbioru najbardziej prawdopodobnych tokenów

Stosowanie obu parametrów razem zapewnia precyzyjną kontrolę. Typowe zalecenie: należy zmieniać tylko jeden parametr naraz. Jednoczesna zmiana obu parametrów utrudnia przewidzenie efektu.

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

Praktyczne wartości temperatury dla poszczególnych zadań

Krótka ściąga dla typowych rodzajów zadań:

Pytania i odpowiedzi oparte na faktach: 0 — wymagana jest dokładność, zmienność nie jest potrzebna
Generowanie kodu: 0–0.2 — składnia musi być poprawna
Podsumowywanie: 0.3–0.5 — pewna zmienność jest akceptowalna
Czat / rozmowa: 0.7–0.9 — naturalne, zróżnicowane odpowiedzi
Kreatywne pisanie: 0.9–1.2 — pożądana jest różnorodność
Burza mózgów / generowanie pomysłów: 1.0–1.5 — warto eksplorować nieoczywiste możliwości

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
    )

Temperatura w API

Temperatura jest obsługiwana przez wszystkie główne API LLM. Prawidłowy zakres wynosi 0–2 dla OpenAI oraz 0–1 dla Anthropic Claude. Przekroczenie wartości maksymalnej powoduje błąd.

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

Gdy sama temperatura nie wystarcza

Sama temperatura nie zawsze zapewnia potrzebną różnorodność lub precyzję. Gdy ustawienie temperature=0 nadal daje zróżnicowane wyniki (w niektórych modelach może się tak zdarzyć z powodu niedeterminizmu obliczeń zmiennoprzecinkowych), należy użyć seed, aby uzyskać rzeczywistą powtarzalność. Gdy wysoka temperatura prowadzi do powstawania nonsensownych wyników, zamiast jeszcze ją zwiększać należy ograniczyć słownik za pomocą top-p lub top-k.

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

Sprawdzenie wiedzy

Co dzieje się z rozkładem prawdopodobieństwa tokenów, gdy temperatura zostanie ustawiona na bardzo wysoką wartość (np. 2.0)?

Podsumowanie: temperatura w LLM-ach

Temperatura steruje losowością próbkowania tokenów, skalując wartości logits przed zastosowaniem softmaxu:

T=0: zachłanne — zawsze wybierany jest najbardziej prawdopodobny token, wynik jest deterministyczny
T=1: standardowe — próbkowanie odbywa się zgodnie z naturalnym rozkładem prawdopodobieństwa
T>1: chaotyczne — rozkład zostaje spłaszczony, losowość wzrasta, a spójność maleje

W zadaniach faktograficznych i związanych z kodem należy stosować niską temperaturę, w czacie średnią, a w zadaniach kreatywnych wysoką. Należy zmieniać tylko temperaturę albo top-p, a nie oba parametry jednocześnie. Następna lekcja: próbkowanie jądrowe top-p.

Często zadawane pytania

Czy lekcja „Czym jest temperatura w LLM-ach” jest bezpłatna?

Tak — pełny tekst „Czym jest temperatura w LLM-ach” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu AI Prompt Engineering, przejdź na CoddyKit PRO. Kurs AI Prompt Engineering zawiera 4 lekcji w sumie.

Co nauczysz się w „Czym jest temperatura w LLM-ach”?

Temperatura jako kontrola kreatywności: 0 = deterministycznie, 2 = chaotycznie, a pomiędzy nimi cała skala. Ćwiczysz AI Prompt Engineering z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć AI Prompt Engineering?

Nie wymagamy żadnego doświadczenia. AI Prompt Engineering w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „Czym jest temperatura w LLM-ach”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji AI Prompt Engineering?

Tak. Każda lekcja AI Prompt Engineering zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do AI Prompt Engineering