Gauge dependence and structured-output corruption in sign-branched repetition penalties: measurements across models, inference stacks, and alternative repetition controls

Resumo Técnico: Dependência de Gauge e Corrupção de Saída Estruturada em Penalidades de Repetição com Ramificação de Sinal

Definição do Problema
O artigo identifica uma falha fundamental na penalidade de repetição multiplicativa amplamente implementada no ecossistema de inferência de LLMs (incluindo Hugging Face, vLLM e llama.cpp). O operador padrão, herdado do modelo CTRL, aplica uma penalidade aos tokens vistos anteriormente ramificando no sinal de seus logits brutos: dividindo os logits positivos por um fator $\theta$ e multiplicando os negativos por $\theta$.

A questão central é que a localização do ponto zero do logit é arbitrária. A função softmax é invariante ao deslocamento ($\text{softmax}(z+c) = \text{softmax}(z)$), o que significa que o objetivo de treinamento de um modelo restringe a distribuição de probabilidade, mas deixa os valores absolutos dos logits (o "gauge" ou calibre) sem restrições. Consequentemente, a ramificação de sinal da penalidade opera em uma coordenada que o processo de treinamento não fixa. Isso leva a duas consequências negativas mensuráveis:

1. Comportamento Indefinido: Uma configuração de penalidade de repetição fixa (ex: $\theta=1.3$) realiza uma operação matemática diferente em diferentes modelos (ou mesmo no mesmo modelo com um viés deslocado), pois a fração de tokens caindo na ramificação de "divisão" vs. "multiplicação" varia drasticamente com base no ponto zero do logit do modelo.
2. Corrupção de Saída Estruturada: A penalidade suprime indiscriminadamente tokens que são exigidos pela gramática (ex: chaves de fechamento em JSON, indentação em código) simplesmente porque eles apareceram antes. Isso causa uma queda catastrófica na validade das saídas estruturadas.

Metodologia
Os autores conduzem uma série de experimentos controlados em cinco modelos (variando de gpt2 a Qwen2.5-7B, incluindo variantes base e RLHF) e dois stacks de inferência (vLLM e llama.cpp) para isolar os efeitos da ramificação de sinal.

• Experimento de Flutuação de Gauge (Consequência 1): Os autores decodificam o mesmo modelo duas vezes com sementes aleatórias e entradas idênticas, mas adicionando uma constante $c$ a todos os logits (simulando um deslocamento no viés do modelo). Para uma intervenção bem definida, a seleção de token greedy deveria permanecer idêntica. Eles medem a "taxa de flutuação" (fração de posições onde o token difere) em $\theta=1.3$ comparado a controles (penalidades subtrativas e penalidades normalizadas).
• Avaliação de Saída Estruturada (Consequência 2): Os autores avaliam o impacto da penalidade em duas tarefas:
  • HumanEval: Gerar código onde delimitadores específicos são necessários.
  • JSONSchemaBench: Gerar objetos JSON contra 200 esquemas do mundo real.
    Eles medem a taxa de saída válida e conforme o esquema e a frequência de "flutuações de delimitador" (onde um token estrutural necessário é incorretamente suprimido).
• Verificação de Cross-Stack: Os experimentos são replicados no vLLM e llama.cpp usando seus samplers nativos para confirmar que o problema é inerente à implementação do operador em todo o ecossistema.
• Correção Proposta: Os autores testam uma variante onde a penalidade é aplicada a log-probabilidades normalizadas ($\log p_i$) em vez de logits brutos ($z_i$), efetivamente removendo a ramificação de sinal, já que todas as log-probabilidades são não-positivas.

Principais Resultados

• Dependência de Gauge: A penalidade padrão de ramificação de sinal é altamente sensível ao ponto zero do logit.
  • Através de cinco checkpoints reais, a fração de tokens vistos com logits positivos (e, portanto, divididos) varia de 0,17 (gpt2) a 0,95 (Qwen2.5-Coder-7B).
  • No experimento controlado de flutuação, deslocar o ponto zero do logit por uma constante de $\pm 5$ faz com a penalidade padrão flutuar de 58% a 96% dos tokens greedy em $\theta=1.3$. Em contraste, as penalidades subtrativas e normalizadas mostram uma taxa de flutuação de 0%.
  • O "custo" da intervenção (medido em log-verossimilhança) varia por um fator de 4,1 dependendo do gauge, enquanto os controles permanecem constantes.
• Falha de Saída Estruturada: A penalidade degrada severamente a geração estruturada.
  • No JSONSchemaBench, aplicar $\theta=1.3$ reduz a taxa de saída JSON válida de 97% para 23%.
  • No HumanEval, a penalidade causa flutuações em tokens estruturais com uma acurácia balanceada de 0,999 contra uma previsão teórica, confirmando que o mecanismo é impulsionado pela penalidade suprimindo delimitadores necessários.
• Prevalência no Ecossistema: A implementação de ramificação de sinal é encontrada no Hugging Face, vLLM, llama.cpp e doze outros motores (ex: TGI, SGLang, Ollama). O problema não é isolado em uma única biblioteca, mas é um artefato sistêmico do design do operador.
• Efetividade da Normalização: Aplicar a penalidade a log-probabilidades normalizadas ($\log \text{softmax}(z)$) elimina ambos os efeitos.
  • A taxa de flutuação de gauge cai para 0,00.
  • A validade do JSON em $\theta=1.3$ recupera-se para 97%.
  • A corrupção de delimitadores diminui em aproximadamente 80x.

Significância e Alegações
O artigo argumenta que a penalidade de repetição multiplicativa padrão não é um "controle escalar limpo", mas uma intervenção de tempo de inferência cujo comportamento é parcialmente determinado por um artefato de treinamento sem restrições (o ponto zero do logit).

• Falta de Portabilidade: Um valor $\theta$ fixo não representa a mesma operação entre diferentes modelos, tornando necessária a sintonia por modelo e por tarefa, mesmo para um parâmetro "padrão".
• Consequências Indesejadas: A penalidade corrompe a saída estruturada ao tratar necessidades gramaticais (que devem se repetir) como repetições indesejadas, um modo de falha que é particularmente agudo para geração de código e JSON.
• Solução: Os autores demonstram que normalizar os logits antes de aplicar a penalidade (ou usar penalidades subtrativas) remove tanto a dependência de gauge quanto a corrupção da saída estruturada. Eles observam que o Hugging Face já fornece um operador LogitNormalization, mas que ele está atualmente desativado por padrão e aplicado após a penalidade, o que falha em resolver o problema.

O artigo conclui que, embora as penalidades de repetição sejam contornos necessários para o comportamento do modelo, a implementação padrão atual introduz "arestas vivas" que comprometem a confiabilidade. Os autores pedem que os mantenedores de stacks adotem a família de penalidades subtrativas ou reordenem a penalidade multiplicativa para operar sobre log-probabilidades normalizadas.