0Pricing
AI Prompt Engineering · Aula

O que é temperatura em LLMs?

A temperatura como controle criativo: 0 = determinístico, 2 = caótico, e tudo entre esses valores.

O que é temperatura em LLMs? é uma aula grátis de AI Prompt Engineering no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de AI Prompt Engineering, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de AI Prompt Engineering inclui 4 aulas no total.

Como os modelos LLM escolhem a próxima unidade

A cada etapa, um LLM produz uma distribuição de probabilidade sobre todas as unidades de seu vocabulário (cerca de 50.000 unidades para GPT). O modelo atribui a cada unidade uma pontuação — um número bruto e não normalizado. Quanto maior a pontuação, mais provável é a unidade.

A temperatura é o parâmetro que controla como essas pontuações brutas são convertidas em probabilidades antes da amostragem.

A função softmax

As pontuações brutas são convertidas em probabilidades usando a função softmax. softmax recebe um vetor de pontuações brutas e produz uma distribuição de probabilidade cuja soma é 1.

Para um exemplo com um vocabulário pequeno de 4 unidades:

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ção gulosa

Quando a temperatura se aproxima de 0, a distribuição softmax colapsa: a unidade com a maior pontuação recebe probabilidade de aproximadamente 1,0, e todas as outras se aproximam de 0. O modelo sempre escolhe a única unidade mais provável.

Isso é chamado de decodificação gulosa. Ela é determinística — a mesma solicitação sempre produz a mesma saída. Zero aleatoriedade, zero criatividade.

# 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: amostragem padrão

Com temperatura = 1, aplica-se softmax sem qualquer redimensionamento — a distribuição de probabilidade reflete a confiança natural do modelo. O modelo faz a amostragem de acordo com essas probabilidades: unidades prováveis aparecem com frequência, enquanto unidades improváveis aparecem raramente, mas às vezes.

Essa é a configuração padrão para a maioria dos casos de uso conversacionais. Ela produz uma saída variada e natural, mantendo a coerência.

# 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: amostragem caótica

Uma temperatura alta (> 1) achata a distribuição de probabilidade — todas as unidades se tornam quase igualmente prováveis. O modelo fica imprevisível e frequentemente incoerente.

Temperaturas > 1,5 raramente são usadas na prática. Elas podem produzir saídas criativas e inesperadas, mas geralmente produzem absurdos.

# 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 como controle de concentração

Conceitualmente, a temperatura controla a concentração da distribuição:

  • Temperatura baixa (0,1–0,4): pico concentrado — o modelo está confiante e escolhe unidades seguras e comuns
  • Temperatura média (0,6–1,0): formato natural — criatividade e coerência equilibradas
  • Temperatura alta (1,2–2,0): distribuição plana — o modelo explora livremente unidades improváveis

Pense nisso como um controle de criatividade: baixa = precisa, alta = ousada.

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

Uma nuance importante: temperatura = 0 torna a amostragem determinística. Para temperatura > 0, cada execução produz uma saída diferente, pois a amostragem é um processo aleatório. A distribuição é fixa, mas a amostra varia.

Para obter saídas reproduzíveis nos testes, defina sempre temperatura = 0. Na produção, quando desejar variação, utilize uma semente se a API oferecer suporte a isso.

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)

Como a temperatura interage com top-p

A temperatura e top-p (amostragem de núcleo) moldam a distribuição de amostragem, mas em etapas diferentes:

  • Temperatura: escala os logits antes de softmax — altera o formato da distribuição completa
  • Top-p: trunca a distribuição até a massa de probabilidade dos p tokens mais prováveis após softmax — amostra apenas do conjunto de tokens mais prováveis

Usar ambos em conjunto oferece um controle preciso. A recomendação usual é ajustar apenas um por vez. Alterar os dois simultaneamente torna o efeito difícil de prever.

# 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áticos de temperatura por tarefa

Referência rápida para tipos comuns de tarefa:

  • Perguntas e respostas factuais: 0 — devem ser precisas, sem necessidade de variação
  • Geração de código: 0–0.2 — a sintaxe deve estar correta
  • Resumo: 0.3–0.5 — alguma variação é aceitável
  • Conversa / conversacional: 0.7–0.9 — respostas naturais e variadas
  • Escrita criativa: 0.9–1.2 — a diversidade é desejável
  • Geração de ideias: 1.0–1.5 — explore opções 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
    )

Temperatura na API

A temperatura é aceita por todas as principais APIs de LLM. O intervalo válido é de 0 a 2 para OpenAI e de 0 a 1 para Anthropic Claude. Exceder o máximo gera um erro.

# 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 a temperatura não é suficiente

A temperatura, sozinha, nem sempre produz a diversidade ou a precisão de que você precisa. Quando temperatura=0 ainda produz uma saída variada (isso pode acontecer em alguns modelos devido ao não determinismo de ponto flutuante), use seed para obter uma reprodutibilidade verdadeira. Quando uma temperatura alta produz um texto sem sentido, limite o vocabulário com top-p ou top-k em vez de aumentar ainda mais a 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ção de conhecimento

O que acontece com a distribuição de probabilidade dos tokens quando a temperatura é definida com um valor muito alto (por exemplo, 2.0)?

Recapitulação: temperatura em LLMs

A temperatura controla a aleatoriedade da amostragem de tokens ao escalar os logits antes de softmax:

  • T=0: guloso — sempre escolhe o token mais provável, de forma determinística
  • T=1: padrão — faz a amostragem de acordo com a distribuição natural de probabilidades
  • T>1: caótico — achata a distribuição, gerando mais aleatoriedade e menos coerência

Use uma temperatura baixa para tarefas factuais e de código, média para conversas e alta para tarefas criativas. Ajuste apenas a temperatura ou top-p por vez, não ambos. Próxima lição: amostragem de núcleo top-p.

Perguntas Frequentes

A aula “O que é temperatura em LLMs?” é grátis?

Sim — o texto completo de “O que é temperatura em LLMs?” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de AI Prompt Engineering, atualize para CoddyKit PRO. O curso de AI Prompt Engineering inclui 4 aulas no total.

O que vou aprender em “O que é temperatura em LLMs?”?

A temperatura como controle criativo: 0 = determinístico, 2 = caótico, e tudo entre esses valores. Você pratica AI Prompt Engineering com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar AI Prompt Engineering?

Nenhuma experiência prévia é necessária. AI Prompt Engineering no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “O que é temperatura em LLMs?”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de AI Prompt Engineering?

Sim. Cada aula de AI Prompt Engineering inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. O que é temperatura em LLMs?
  2. Amostragem de núcleo top-p
  3. Amostragem top-k
  4. Escolhendo parâmetros para seu caso de uso
← Voltar para AI Prompt Engineering