ZeroCoder: Can LLMs Improve Code Generation Without Ground-Truth Supervision?

Título: ZeroCoder: Podem os LLMs Melhorar a Geração de Código sem Supervisão de Verdade Terrena?

1. O Problema

A geração de código é uma tarefa fundamental na engenharia de software. O paradigma de Aprendizado por Reforço com Recompensas Verificáveis (RLVR) tem se mostrado eficaz, otimizando Modelos de Linguagem (LLMs) com base em feedback de execução (passar/falhar em testes). No entanto, a maioria das pipelines de RLVR depende criticamente de supervisão de verdade terrena (ground-truth), como testes unitários curados por humanos ou gerados a partir de soluções de referência.

À medida que esses recursos se tornam escassos e caros para escalar, o progresso fica limitado. Trabalhos anteriores tentaram usar testes auto-gerados para fornecer recompensas, mas falharam devido à baixa qualidade desses testes: modelos geram testes pouco discriminativos, permitindo que soluções erradas passem e gerando sinais de recompensa ruidosos. A questão central é: é possível melhorar a geração de código sem qualquer supervisão externa (rótulos), apenas usando a interação entre código e testes gerados pelo próprio modelo?

2. Metodologia: ZeroCoder

O ZeroCoder é um framework de co-evolução totalmente livre de rótulos que treina simultaneamente dois papéis em um único modelo de linguagem:

1. Coder (Codificador): Gera soluções candidatas para um problema.
2. Tester (Testador): Gera testes unitários para verificar essas soluções.

O processo funciona através de um ciclo de feedback baseado na execução:

A. Co-evolução e Matriz de Aprovação

Para cada problema, o modelo gera $N$ soluções e $M$ testes. Eles são executados em pares, formando uma Matriz de Aprovação (Passing Matrix) $E$, onde cada entrada indica se uma solução passou em um teste específico.

• Ideia Central: Em vez de tratar um papel como fixo, ambos são treinados juntos. Testes mais fortes forçam o codificador a ser mais preciso; codificadores melhores forçam o testador a criar testes mais discriminativos.

B. Filtro Pré-RL Baseado em Rank (Offline)

Para evitar problemas muito fáceis (todos passam) ou muito difíceis (todos falham), que geram gradientes de política nulos, o ZeroCoder aplica um filtro antes do treinamento.

• Utiliza o rank (posto) da matriz de aprovação como uma métrica não supervisionada de diversidade de interação.
• Apenas problemas com matrizes de rank suficientemente alto (indicando padrões de execução variados e não redundantes) são mantidos para o treinamento de RL.

C. Construção de Recompensas Específicas por Papel

O sistema utiliza um algoritmo de seleção (Selector) para identificar um subconjunto de consenso de soluções e testes prováveis de estarem corretos, baseado na matriz $E$.

• Recompensa do Codificador: Binária. Recebe recompensa positiva se a solução for selecionada no subconjunto de consenso.
• Recompensa do Testador: Composta por três termos para equilibrar validade e discriminatividade:
  1. Termo de Concordância (Proxy-Agreement): O teste passa em uma solução de consenso.
  2. Termo de Discriminação (Mutation-based): O teste deve "matar" variantes mutadas da solução (usando mutation testing). Isso impede que o modelo gere testes triviais (ex: assert True).
  3. Termo de Formato: Penaliza testes que não são executáveis.
  • Um curriculum (cronograma) ajusta o peso do termo de discriminação ao longo do tempo, começando com validade e aumentando a exigência de discriminatividade.

D. Seletores e o Problema de "Selector Drift"

O papel usa algoritmos para escolher o consenso:

• Seletores Estáticos: MaxPass, CodeT e B4 (Bayesiano).
• Problema Identificado: Os seletores estáticos sofrem de "Selector Drift". À medida que a capacidade do modelo muda durante o treinamento, as suposições fixas dos seletores tornam-se descalibradas, gerando recompensas ruidosas.

E. Solução: $DyB4$ (Dynamic B4)

Para mitigar o drift, o autores propõem o $DyB4$, uma variante dinâmica do seletor Bayesiano B4.

• Ele recalibra os hiperparâmetros de prior do seletor usando um conjunto de calibração extremamente pequeno (apenas 10 instâncias rotuladas).
• Isso permite que o seletor se adapte à confiabilidade atual do modelo durante o treinamento, mantendo a qualidade da seleção sem depender de grandes conjuntos de dados rotulados.

3. Contribuições Principais

1. Framework ZeroCoder: Um método de RLVR totalmente livre de rótulos que co-otimiza geração de código e testes, demonstrando que interações auto-geradas podem servir como sinal de supervisão eficaz.
2. Análise de Selector Drift e $DyB4$: Identificação de que regras de seleção fixas falham em cenários de co-evolução não estacionária. Proposta de um seletor Bayesiano dinâmico que usa calibração mínima para manter a precisão.
3. Validação Empírica: Demonstração de que o método supera modelos base e se aproxima do desempenho de treinamento supervisionado por oráculo (com verdade terrena completa).

4. Resultados Experimentais

Os experimentos foram realizados em três famílias de modelos (Qwen2.5-1.5B, Qwen3-4B, Qwen2.5-Coder-7B) e seis benchmarks (MBPP, LiveCodeBench, APPS, CodeForces).

• Cenário Livre de Rótulos: O ZeroCoder com seletores estáticos melhorou a geração de código em até 14.5% e a geração de testes em 24.3% em relação ao modelo base (Qwen2.5-Coder-7B).
• Cenário com Pequena Calibração ($DyB4$): Ao adicionar apenas 10 instâncias rotuladas para calibração dinâmica, o ganho na geração de código subiu para 21.6% e na geração de testes para 24.3%.
• Comparação com Oráculo: O desempenho do ZeroCoder com $DyB4$ foi competitivo com o treinamento supervisionado por oráculo (que usa todas as soluções e testes reais), alcançando cerca de 42.2% de Pass@1 em benchmarks de código, comparado a 43.2% do oráculo.
• Ablação: A remoção da recompensa baseada em mutação (discriminação) degradou significativamente o desempenho, provando que testes discriminativos são essenciais para o ciclo de co-evolução.

5. Significado e Impacto

O trabalho demonstra que a dependência de testes curados manualmente para o treinamento de RL em geração de código pode ser superada.

• Escalabilidade: Permite o treinamento contínuo de modelos de código sem o gargalo de custos de anotação humana.
• Qualidade de Dados: A co-evolução gera dados de treinamento mais ricos e adaptativos do que pipelines estáticos.
• Eficiência de Rótulos: Mostra que uma quantidade ínfima de dados rotulados (10 exemplos) é suficiente para calibrar o sistema e atingir desempenho de ponta, tornando a técnica viável para cenários com recursos limitados.

Em resumo, o ZeroCoder estabelece um novo paradigma onde a interação dinâmica entre a geração de código e a geração de testes cria um ciclo virtuoso de melhoria, eliminando a necessidade de supervisão externa massiva.