Resumo Técnico: Do Raciocínio ao Código: Otimização GRPO para Línguas Sub-representadas

Declaração do Problema

Gerar código preciso e executável em linguagens de programação sub-representadas (por exemplo, Prolog, Lisp) continua sendo um desafio significativo para Modelos de Linguagem de Grande Escala (LLMs). Embora os modelos se destaquem em linguagens de alto recurso, como Python, eles falham consistentemente em programação lógica devido à escassez de dados públicos de treinamento. Essa escassez de dados leva a modos de falha específicos: alucinação de predicados inexistentes, imposição de fluxo de controle imperativo sobre paradigmas declarativos e tratamento inadequado de unificação e retrocesso. O Ajuste Fino Supervisionado (SFT) padrão é insuficiente porque depende de exemplos escritos por humanos, que são escassos, e não otimiza diretamente a correção de execução.

Metodologia

O artigo propõe uma estrutura de Aprendizado por Reforço com Recompensas Verificáveis (RLVR) que utiliza feedback orientado à execução para treinar LLMs de pequena escala (família Qwen2.5-Coder, de 0,5B a 7B parâmetros), sem depender de conjuntos de dados extensivamente curados por humanos.

Estrutura Central

• Algoritmo: Os autores empregam a Otimização Relativa de Política em Grupo (GRPO), um algoritmo de gradiente de política que elimina a necessidade de uma rede de função de valor separada (diferentemente do PPO). A GRPO estima a vantagem de uma saída em relação a um grupo de saídas de pares amostradas a partir do mesmo prompt, reduzindo a sobrecarga computacional.
• Loop de Treinamento: O sistema integra um interpretador Prolog (via PySwip) diretamente no loop de treinamento. O LLM gera código em resposta a prompts em linguagem natural (especificamente do conjunto de dados GSM8K), e o interpretador executa o código para fornecer um sinal de correção de verdade fundamental.
• Sistema de Recompensa: Uma função de recompensa multiobjetivo agrega quatro sinais:
  1. Recompensas de Formato: Penalidades e bônus por aderir a um modelo XML estrito (<reasoning>, <code>, <query>), garantindo que o código seja extraível. Uma penalidade específica é aplicada se a consulta estiver incorretamente aninhada dentro do bloco de código.
  2. Recompensas de Correção: Baseadas nos resultados de execução:
     • +1.0: Correspondência exata com a verdade fundamental.
     • -1.0: Erro lógico (executa, mas resultado errado).
     • -0.5: Erro de sintaxe (falha ao compilar/executar).
     • -0.1: Tempo esgotado ou nenhuma saída.

Intervenções Técnicas Chave

Os autores identificaram um modo de falha denominado "contração de raciocínio", onde o treinamento GRPO padrão com uma penalidade de divergência Kullback–Leibler (KL) causou o colapso do modelo de 7B em padrões de saída curtos e memorizados, degradando a precisão ao longo do tempo. Para abordar isso, eles introduziram duas modificações críticas:

1. Remoção da Divergência KL: Eliminar a penalidade KL permitiu que a política se desviasse mais da linha de base supervisionada, permitindo que o modelo internalizasse o paradigma distinto de programação lógica.
2. Recompensa Consciente de Comprimento: Um mecanismo de recompensa específico foi adicionado para encadear cadeias de raciocínio dentro de uma faixa de comprimento de token-alvo, impedindo que o modelo truncasse seu processo de raciocínio.

Contribuições Principais

1. Novo Estado da Arte para Prolog: Demonstrou que o RLVR com feedback baseado em execução pode compensar a escassez extrema de dados, estabelecendo um novo benchmark para geração de código Prolog no GSM8K usando um modelo de 7B parâmetros.
2. Ablação Sistemática das Dinâmicas GRPO: Identificou a "contração de raciocínio" como um modo de falha específico do RL regularizado por KL em programação lógica e caracterizou as condições sob as quais relaxar essa restrição é benéfico.
3. Generalização Além da Aritmética: Mostrou que as melhorias se transferem para 20 tarefas diversas de Prolog (Rosetta Code) e para o benchmark GSM-Symbolic, onde a precisão zero-shot mais que dobrou.
4. Validade Cross-Linguagem: Validou a abordagem em Lisp, demonstrando que o RL orientado por interpretador é eficaz em famílias distintas de linguagens sub-representadas.

Resultados

Os experimentos foram conduzidos no conjunto de dados GSM8K, com avaliações no Rosetta Code e GSM-Symbolic (variantes P1 e P2).

• Desempenho GSM8K:
  • O Qwen2.5-Coder-7B otimizado (Zero-shot, sem KL, restrição de comprimento) alcançou um pass@4 de 0,882.
  • Em configurações One-shot, a mesma configuração atingiu 0,893, superando o PROPER (Mistral-7B, 0,72), Llama 3.3 70B (0,839) e Qwen2.5-Coder-32B (0,873).
  • Sem a remoção do KL, o modelo de 7B sofreu com desvio de desempenho, caindo de uma linha de base de 0,814 para 0,672.
• GSM-Symbolic:
  • No desafiador conjunto de dados P2 (requerendo manipulação simbólica mais profunda), o pass@4 zero-shot para o modelo de 7B aumentou de uma linha de base de 0,298 para 0,673.
• Desempenho em Lisp:
  • A abordagem melhorou o pass@4 zero-shot em Lisp de 0,572 para 0,876. No entanto, a remoção da restrição KL produziu ganhos mais modestos em Lisp comparado ao Prolog, sugerindo que o treinamento "não regularizado" é mais crítico para linguagens altamente especializadas e de baixo recurso.
• Rosetta Code:
  • O modelo de 7B quase dobrou sua linha de base zero-shot, alcançando um pass@4 de 0,46.

Significado e Alegações

O artigo argumenta que, para linguagens formais com semântica determinística, o próprio interpretador pode servir como o sinal de treinamento primário, substituindo os dados humanos escassos dos quais as abordagens atuais dependem. Ao tratar o sistema simbólico não apenas como uma ferramenta, mas como um "professor" que supervisiona a rede neural por meio de rastros de execução, os autores fornecem um supervisor rigoroso e automatizado.

O trabalho alega oferecer um caminho robusto e adaptável para aprimorar a geração de código em linguagens sub-representadas. Sugere que fechar a lacuna entre a intuição neural e o rigor simbólico não requer escala massiva ou conjuntos de dados massivos, mas sim uma mudança no objetivo de aprendizado em direção à maximização da correção de execução via aprendizado por reforço. Os autores concluem que essa metodologia permite que os modelos respeitem a sintaxe e a lógica das linguagens-alvo, aproximando-se do "Santo Graal" da programação, onde um usuário declara um problema e o computador o resolve por meio de código lógico e verificável.