Você já ouviu falar sobre os “logits“? Se não, prepare-se pra um post mais técnico de como LLMs funcionam por baixo dos panos e como eles fazem a inferência pra escolher a próxima palavra (na verdade, o próximo token) da frase que estão gerando.
De forma bem direta, logits são as pontuações brutas, “cruas” e não normalizadas geradas pela camada de projeção linear final da rede neural de um modelo de IA.
Voltando pro começo, quando você vai treinar um LLM do zero, você faz a tokenização (a separação das palavras do seu conjunto de treinamento em tokens, ou pedaços de palavras, como os tokens “in” e “feliz” que formam a palavra “infeliz”). Essa etapa acontece antes do treinamento da rede neural, e você treina o tokenizador sobre o corpus pra definir um vocabulário fixo, que geralmente varia entre 50.000 a mais de 100.000 tokens. Vamos supor 100.000 pro nosso exemplo.
Quando você manda um prompt, um modelo instruído vai tentar “completá-lo” dando uma resposta. Pra facilitar, vamos dar o exemplo de completar uma frase. Suponha a frase: “O céu é ____“. O LLM vai processar essa informação através de dezenas de blocos de atenção e feedforward (o coração do Transformer), e no final, uma camada de projeção linear cospe um vetor 100.000 logits de tamanho, o tamanho exato do nosso vocabulário. Ou seja, ele atribui uma pontuação bruta a todos os 100.000 tokens que ele conhece em seu dicionário, avaliando qual faria mais sentido a seguir.
Exemplo hipotético de logits para o próximo token de “O céu é ____”:
["azul" = 5.7,
"lindo" = 5.0,
"abacaxi" = -3.1,
...,
"Maria" = -2.7,
"rosado" = 4.8,
...]
Como os logits não são limitados entre 0 e 1, o treinamento via gradiente descendente consegue operar de forma mais estável numericamente (evitando problemas com valores extremamente pequenos). Mas esses valores brutos não são intuitivos pra nós, então, no final, é aplicada uma função matemática chamada Softmax, que transforma esses valores em porcentagens de 0 a 100%. No nosso exemplo acima, poderia ser algo como:
["azul" = 18.7%,
"lindo" = 17.3%,
"abacaxi" = 0.001%,
...,
"Maria" = 0.001%,
"rosado" = 15.9%,
...]
Mas antes de passarem por essa função Softmax, o sistema pode manipular matematicamente esses logits pra controlar como o modelo escreve. O parâmetro mais famoso pra fazer isso é a Temperatura. A fórmula é basicamente softmax(logits/Temperatura), assim:
-
Se você usa uma Temperatura Baixa (ex: 0.1), os logits são divididos por 0.1, o que equivale a multiplicá-los por 10. Isso amplifica drasticamente a diferença entre as pontuações, fazendo a IA ser mais conservadora, factual e previsível (o logit de “azul” vai esmagar todos os outros).
-
Já com uma Temperatura alta (ex: 1.5), a divisão reduz as diferenças e as pontuações se aproximam umas das outras (a IA passa a dar mais chance pra palavras menos óbvias, ficando muito mais criativa e diversificada, mas consequentemente com mais risco de alucinar).
É também nesse momento que entram filtros famosos como o Top-K (onde o modelo ignora os milhares de logits baixos e foca só nos K valores maiores). Depois, já no espaço de probabilidades (após o Softmax), entra o Top-P, também chamado de nucleus sampling, que seleciona apenas os tokens cujas probabilidades somadas atingem um limiar (ex: 90%). Outros filtros como o Repetition Penalty (que penaliza tokens já gerados para evitar repetições) também podem ser aplicados.
Depois de tudo isso, a IA “rola os dados”, escolhe o token, adiciona ele ao texto e recomeça o ciclo. Esse processo autoregressivo se repete dezenas ou centenas de vezes por segundo até a resposta estar completa.
Se você roda modelos localmente com ferramentas como Ollama, LM Studio, llama.cpp ou text-generation-webui, provavelmente já viu esses parâmetros expostos na interface ou na linha de comando. Agora você sabe exatamente o que eles estão fazendo por baixo dos panos: manipulando os logits antes (ou depois) do Softmax pra controlar o comportamento do modelo.
Usando a biblioteca Transformers da HuggingFace, dá pra ver os logits diretamente:
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch
model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3-8B")
tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3-8B")
inputs = tokenizer("O céu é", return_tensors="pt")
with torch.no_grad():
output = model(**inputs)
next_token_logits = output.logits[0, -1, :]É esse vetor “next_token_logits” que contém a pontuação de cada token do vocabulário. Na prática, o “model.generate()” faz isso em loop pra você, aplicando automaticamente os parâmetros de temperature, top_k, top_p e repetition_penalty a cada passo antes de escolher o próximo token.
E é mais ou menos isso! 🙂 Saber como a salsicha é feita por baixo dos panos ajuda muito a “domar” essas IAs.
De 0 a 10, o quanto você recomendaria este artigo para um amigo?