¿Qué es la temperatura en los LLM?
La temperatura como control creativo: 0 = determinista, 2 = caótico, y todo lo intermedio.
¿Qué es la temperatura en los LLM? es una lección gratuita de AI Prompt Engineering en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de AI Prompt Engineering, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de AI Prompt Engineering incluye 4 lecciones en total.
Cómo eligen los LLM el siguiente token
En cada paso, un LLM genera una distribución de probabilidad sobre todos los tokens de su vocabulario (aproximadamente 50 000 tokens en GPT). El modelo asigna a cada token una puntuación denominada logit: un número bruto sin normalizar. Cuanto mayor sea el logit, más probable será el token.
La temperatura es el parámetro que controla cómo se convierten estos logits brutos en probabilidades antes del muestreo.
La función softmax
Los logits se convierten en probabilidades mediante la función softmax. Softmax recibe un vector de logits y genera una distribución de probabilidad cuya suma es 1.
Para un ejemplo con un vocabulario pequeño de 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%Temperatura = 0: decodificación greedy
Cuando la temperatura se aproxima a 0, la distribución softmax colapsa: el token con el logit más alto obtiene una probabilidad aproximada de 1,0 y todos los demás se aproximan a 0. El modelo siempre selecciona el token más probable.
Esto se denomina decodificación greedy. Es determinista: el mismo prompt siempre produce la misma salida. Cero aleatoriedad, cero creatividad.
# 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 0Temperatura = 1: muestreo estándar
Temperatura = 1 aplica softmax sin escalado; la distribución de probabilidad refleja la confianza natural del modelo. El modelo realiza el muestreo según estas probabilidades: los tokens probables aparecen con frecuencia y los improbables aparecen rara vez, aunque a veces lo hacen.
Es el valor predeterminado para la mayoría de los casos de uso conversacionales. Produce salidas variadas y naturales, sin dejar de ser coherente.
# 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 oftenTemperatura = 2: muestreo caótico
Una temperatura alta (> 1) aplana la distribución de probabilidad: todos los tokens adquieren una probabilidad más similar. El modelo se vuelve impredecible y, a menudo, incoherente.
En la práctica, rara vez se utiliza una temperatura > 1,5. Puede producir salidas creativas e inesperadas, pero normalmente genera incoherencias.
# 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 como control de nitidez
Conceptualmente, la temperatura controla la nitidez de la distribución:
- Temperatura baja (0,1–0,4): pico pronunciado; el modelo tiene confianza y selecciona tokens seguros y comunes
- Temperatura media (0,6–1,0): forma natural; equilibra creatividad y coherencia
- Temperatura alta (1,2–2,0): distribución plana; el modelo explora libremente tokens improbables
Considérela como un control de creatividad: baja = precisión, alta = carácter aventurero.
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 y determinismo
Un matiz importante: temperature = 0 hace determinista el muestreo. Con temperature > 0, cada ejecución produce una salida diferente porque el muestreo es un proceso aleatorio. La distribución es fija, pero la muestra varía.
Para obtener salidas reproducibles durante las pruebas, establezca siempre temperature = 0. En producción, si desea variación, use seed si la API lo admite.
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)Cómo interactúa la temperatura con top-p
La temperatura y top-p (muestreo de núcleo) dan forma a la distribución de muestreo, pero en etapas diferentes:
- Temperatura: escala los logits antes de softmax; cambia la forma de toda la distribución
- Top-p: trunca la distribución a la masa de probabilidad top-p después de softmax; solo muestrea del conjunto de tokens más probables
Usar ambos parámetros proporciona un control preciso. La recomendación habitual es ajustar solo uno a la vez. Cambiar ambos simultáneamente hace que el efecto sea difícil de predecir.
# 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
)Valores prácticos de temperatura según la tarea
Referencia rápida para tipos de tareas habituales:
- Preguntas y respuestas fácticas: 0 — deben ser precisas, no se necesita variación
- Generación de código: 0–0.2 — la sintaxis debe ser correcta
- Resumen: 0.3–0.5 — se acepta cierta variación
- Chat / conversación: 0.7–0.9 — respuestas naturales y variadas
- Escritura creativa: 0.9–1.2 — se busca diversidad
- Lluvia de ideas / ideación: 1.0–1.5 — permite explorar opciones inesperadas
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 en la API
La temperatura es un parámetro admitido por las principales API de LLM. El intervalo válido es 0–2 para OpenAI y 0–1 para Anthropic Claude. Superar el máximo genera un error.
# 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}]
)Cuando la temperatura no es suficiente
La temperatura por sí sola no siempre produce la diversidad o precisión que necesita. Cuando temperature=0 sigue produciendo una salida variable (puede ocurrir en algunos modelos debido al no determinismo de coma flotante), use seed para lograr una reproducibilidad real. Cuando una temperatura alta produce resultados incoherentes, limite el vocabulario con top-p o top-k en lugar de aumentar aún más 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 seedComprobación de conocimientos
¿Qué ocurre con la distribución de probabilidad de los tokens cuando temperature se establece en un valor muy alto (por ejemplo, 2.0)?
Recapitulación: la temperatura en los LLM
La temperatura controla la aleatoriedad del muestreo de tokens al escalar los logits antes de softmax:
- T=0: greedy — siempre selecciona el token más probable, de forma determinista
- T=1: estándar — muestrea según la distribución natural de probabilidad
- T>1: caótica — aplana la distribución, aumenta la aleatoriedad y reduce la coherencia
Use una temperatura baja para tareas fácticas y de código, media para chat y alta para tareas creativas. Ajuste solo la temperatura o top-p cada vez, no ambos. Próxima lección: muestreo de núcleo top-p.
Preguntas frecuentes
¿La lección «¿Qué es la temperatura en los LLM?» es gratis?
Sí — el texto completo de «¿Qué es la temperatura en los LLM?» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de AI Prompt Engineering, actualiza a CoddyKit PRO. El curso de AI Prompt Engineering incluye 4 lecciones en total.
¿Qué aprenderé en «¿Qué es la temperatura en los LLM?»?
La temperatura como control creativo: 0 = determinista, 2 = caótico, y todo lo intermedio. Practicas AI Prompt Engineering con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar AI Prompt Engineering?
No se requiere experiencia previa. AI Prompt Engineering en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.
¿Cuánto tiempo toma la lección «¿Qué es la temperatura en los LLM?»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de AI Prompt Engineering?
Sí. Cada lección de AI Prompt Engineering incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- ¿Qué es la temperatura en los LLM?
- Muestreo de núcleo Top-p
- Muestreo Top-k
- Elección de parámetros para su caso de uso