AI Prompt Engineering · Lezione

Che cos’è la temperatura negli LLM?

La temperatura come controllo della creatività: 0 = deterministico, 2 = caotico, con tutti i valori intermedi

Lezione 1 di 413 passaggi

Che cos’è la temperatura negli LLM? è una lezione AI Prompt Engineering gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento AI Prompt Engineering, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso AI Prompt Engineering include 4 lezioni in totale.

Come gli LLM scelgono il token successivo

A ogni passaggio, un LLM restituisce una distribuzione di probabilità su tutti i token del proprio vocabolario (~50.000 token per GPT). Il modello assegna a ciascun token un punteggio chiamato logit — un numero grezzo e non normalizzato. Un logit più alto indica un token più probabile.

La temperatura è il parametro che controlla come questi logit grezzi vengono convertiti in probabilità prima del campionamento.

La funzione softmax

I logit vengono convertiti in probabilità tramite la funzione softmax. Softmax prende un vettore di logit e restituisce una distribuzione di probabilità la cui somma è 1.

Per un esempio con un vocabolario ridotto di 4 token:

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: decodifica greedy

Quando la temperatura si avvicina a 0, la distribuzione softmax collassa: il token con il logit più alto riceve una probabilità di circa 1,0 e tutte le altre tendono a 0. Il modello sceglie sempre il singolo token più probabile.

Si parla di decodifica greedy. È deterministica: lo stesso prompt produce sempre lo stesso output. Nessuna casualità, nessuna creatività.

# 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: campionamento standard

La temperatura = 1 applica softmax senza ridimensionamento: la distribuzione di probabilità riflette la sicurezza naturale del modello. Il modello campiona in base a queste probabilità: i token probabili compaiono spesso, quelli improbabili raramente ma talvolta.

Questa è l'impostazione predefinita per la maggior parte dei casi d'uso conversazionali. Produce output vari e naturali, mantenendo comunque la coerenza.

# 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: campionamento caotico

Una temperatura alta (> 1) appiattisce la distribuzione di probabilità: tutti i token diventano più o meno ugualmente probabili. Il modello diventa imprevedibile e spesso incoerente.

Una temperatura > 1,5 viene usata raramente nella pratica. Può produrre output creativi e inaspettati, ma di solito genera nonsense.

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

La temperatura come controllo della concentrazione

Concettualmente, la temperatura controlla la concentrazione della distribuzione:

Temperatura bassa (0,1–0,4): picco netto — il modello è sicuro e sceglie token comuni e affidabili
Temperatura media (0,6–1,0): forma naturale — equilibrio tra creatività e coerenza
Temperatura alta (1,2–2,0): distribuzione piatta — il modello esplora liberamente token improbabili

La consideri un selettore della creatività: bassa = precisa, alta = avventurosa.

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 e determinismo

Una precisazione importante: temperature = 0 rende il campionamento deterministico. Per temperature > 0, ogni esecuzione produce un output diverso, perché il campionamento è un processo casuale. La distribuzione è fissa, ma il campione varia.

Per ottenere output riproducibili nei test, imposti sempre temperature = 0. In produzione, se desidera una certa variabilità, utilizzi un seed se l'API lo supporta.

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)

Come interagisce la temperatura con top-p

La temperatura e top-p (nucleus sampling) influenzano entrambi la distribuzione di campionamento, ma in fasi diverse:

Temperatura: ridimensiona i logits prima della softmax — modifica la forma dell'intera distribuzione
Top-p: tronca la distribuzione fino a ottenere la massa di probabilità top-p dopo la softmax — esegue il campionamento solo dall'insieme dei token più probabili

Utilizzarli entrambi consente un controllo preciso. La raccomandazione consueta è modificare un solo parametro alla volta. Cambiare entrambi contemporaneamente rende difficile prevedere l'effetto.

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

Valori pratici della temperatura in base all'attività

Riferimento rapido per i tipi di attività più comuni:

Domande e risposte fattuali: 0 — è necessaria la precisione, senza bisogno di variabilità
Generazione di codice: 0–0.2 — la sintassi deve essere corretta
Riepilogo: 0.3–0.5 — è accettabile una certa variabilità
Chat / conversazione: 0.7–0.9 — risposte naturali e varie
Scrittura creativa: 0.9–1.2 — è auspicabile la diversità
Brainstorming / ideazione: 1.0–1.5 — per esplorare opzioni inaspettate

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
    )

La temperatura nell'API

Il parametro temperature è accettato da tutte le principali API per LLM. L'intervallo valido è 0–2 per OpenAI e 0–1 per Anthropic Claude. Il superamento del valore massimo genera un errore.

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

Quando la temperatura non basta

La sola temperatura non produce sempre il livello di diversità o precisione necessario. Quando temperature=0 produce comunque un output variabile (può accadere in alcuni modelli a causa del non determinismo in virgola mobile), utilizzi seed per ottenere una vera riproducibilità. Quando una temperatura elevata produce risultati senza senso, limiti il vocabolario con top-p o top-k invece di aumentare ulteriormente la temperatura.

# 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

Verifica delle conoscenze

Che cosa accade alla distribuzione di probabilità sui token quando la temperatura viene impostata su un valore molto alto, ad esempio 2.0?

Rispondi nella lezione interattiva

Riepilogo: la temperatura negli LLM

La temperatura controlla la casualità del campionamento dei token ridimensionando i logits prima della softmax:

T=0: greedy — seleziona sempre il token più probabile, in modo deterministico
T=1: standard — esegue il campionamento secondo la distribuzione di probabilità naturale
T>1: caotica — appiattisce la distribuzione, aumentando la casualità e riducendo la coerenza

Utilizzi una temperatura bassa per le attività fattuali e il codice, media per la chat e alta per le attività creative. Modifichi solo la temperatura o top-p alla volta, non entrambi. Prossima lezione: nucleus sampling con top-p.

Gratis per iniziare

Impara AI Prompt Engineering con un tutor IA — gratis

Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.

Corsi: 53
Lezioni: 199

Inizia a imparare gratis Visualizza il corso completo

Domande Frequenti

La lezione «Che cos’è la temperatura negli LLM?» è gratuita?

Sì — il testo completo di «Che cos’è la temperatura negli LLM?» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso AI Prompt Engineering, passa a CoddyKit PRO. Il corso AI Prompt Engineering include 4 lezioni in totale.

Cosa imparerò in «Che cos’è la temperatura negli LLM?»?

La temperatura come controllo della creatività: 0 = deterministico, 2 = caotico, con tutti i valori intermedi Eserciti AI Prompt Engineering con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare AI Prompt Engineering?

Non è richiesta alcuna esperienza precedente. AI Prompt Engineering su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Che cos’è la temperatura negli LLM?»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione AI Prompt Engineering?

Sì. Ogni lezione AI Prompt Engineering include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

Che cos’è la temperatura negli LLM?
Nucleus sampling con top-p
Sampling con top-k
Scelta dei parametri per il proprio caso d’uso

← Torna a AI Prompt Engineering