Agnostics: Learning to Code in Any Programming Language via Reinforcement with a Universal Learning Environment

O artigo apresenta o Agnostics, um pipeline de pós-treinamento agnóstico à linguagem que utiliza aprendizado por reforço com recompensas verificáveis por meio de comportamento observável, permitindo que modelos de linguagem de pequeno porte aprendam a codificar em qualquer linguagem de programação sem a necessidade de engenharia específica para cada uma, alcançando desempenho de ponta em linguagens de baixo recurso.

O essencial

Imagine que você tem um gênio da lâmpada (um Modelo de Linguagem, ou LLM) que é incrivelmente inteligente. Ele sabe escrever códigos em Python e JavaScript como se fosse um programador sênior de 20 anos de experiência. Mas, se você pedir para ele escrever um código em Fortran (usado em supercomputadores científicos) ou Lua (usado em jogos), ele começa a gaguejar, inventar coisas que não existem e falhar miseravelmente.

Por que isso acontece?

1. Falta de livros: O gênio foi treinado lendo milhões de livros de Python, mas só encontrou alguns panfletos sobre Fortran.
2. O problema do "Treinamento Específico": Para ensinar o gênio a falar uma nova língua, os pesquisadores tradicionais precisam criar um "professor particular" (um conjunto de testes e correções) específico para aquela língua. Fazer isso para 100 línguas diferentes é caro, demorado e chato. É como ter que contratar um professor novo para cada dialeto de uma região.

A Solução: O "Agnostics" (O Mestre Universal)

Os autores deste paper criaram uma técnica chamada Agnostics. A ideia central é brilhante na sua simplicidade: não importa como o código foi escrito, o que importa é o que ele faz.

Pense no Agnostics como um inspetor de trânsito universal.

• Se um carro (o código) chega em um cruzamento, o inspetor não se importa se o carro é um Ford, um Toyota ou um carro feito de madeira.
• Ele só se importa se o carro parou no sinal vermelho e seguiu a direção certa.
• Se o carro obedeceu ao sinal, o motorista ganha um ponto. Se não, ganha zero.

O Agnostics faz exatamente isso com o código: ele ignora a sintaxe (as regras gramaticais da linguagem) e foca apenas no comportamento (a entrada e a saída).

Como funciona a mágica? (Passo a Passo)

1. Tradução para o "Idioma da Verdade":
   Os pesquisadores pegam problemas de programação antigos (que geralmente são escritos para Python) e usam um outro gênio (um LLM) para reescrevê-los. Em vez de pedir "Faça uma função em Python que some dois números", eles transformam o pedido para: "Leia dois números da tela, some-os e escreva o resultado na tela". Isso torna o problema agnóstico (neutro) em relação à linguagem.

2. A "Caixa Preta" (O Verificador):
   Eles criam um ambiente seguro (uma "caixa de areia" ou sandbox) onde o código é executado.

   • Você diz ao sistema: "Para rodar código em R, use este comando; para Fortran, use aquele".
   • O sistema pega a solução do modelo, roda o código, vê se a saída bate com o esperado e dá uma nota.
   • É como se você dissesse ao seu filho: "Não importa se você usa o lápis azul ou vermelho, desde que o desenho fique dentro das linhas".

3. Aprendizado por Reforço (O Treino de Atleta):
   O modelo tenta resolver o problema.

   • Se errar, o "inspetor" diz: "Não foi isso, tente de novo".
   • Se acertar, o modelo ganha uma recompensa.
   • Com o tempo, o modelo aprende a "pensar" na lógica do problema, e não apenas a decorar a sintaxe de uma língua específica.

Os Resultados: Pequenos Gigantes

O paper testou isso em 5 línguas "pobres" (Lua, Julia, R, OCaml e Fortran). O resultado foi impressionante:

• O "Guerreiro de 4 Bilhões": Eles pegaram um modelo pequeno e barato (Qwen 3 de 4 bilhões de parâmetros) e o treinaram com o Agnostics.
• O Resultado: Esse modelo pequeno passou a performar tão bem quanto modelos gigantes de 16 a 70 bilhões de parâmetros nessas línguas difíceis.
• A Analogia: É como se um atleta de 1,60m, treinado com a técnica certa, conseguisse bater recordes de salto em altura de atletas de 2,00m que treinam no método antigo.

Por que isso é importante para o mundo?

1. Democratização: Agora, cientistas que usam Fortran para simular mudanças climáticas, ou médicos que usam R para analisar dados, podem usar IA poderosa sem precisar de supercomputadores caros.
2. Facilidade: Para adicionar uma nova língua ao sistema, não é preciso contratar uma equipe de engenheiros. Basta um pequeno arquivo de configuração (como uma receita de bolo de 5 linhas) dizendo como instalar e rodar aquela língua.
3. Fim do "Viés de Linguagem": A IA deixa de ser um especialista apenas em Python e JavaScript e se torna um poliglota real, capaz de ajudar em qualquer área da ciência e engenharia.

Em resumo: O Agnostics é como um tradutor universal que ensina a IA a focar no resultado e não na forma. Ele permite que modelos pequenos e acessíveis se tornem mestres em qualquer linguagem de programação, desde que você lhes dê uma chance de praticar em um ambiente justo e neutro.

Resumo técnico

1. O Problema

Os Grandes Modelos de Linguagem (LLMs) demonstram excelente desempenho na geração de código para linguagens de alto recurso (como Python e JavaScript), mas falham significativamente em linguagens de baixo recurso (ex: Fortran, Julia, R, OCaml, Lua). Essas linguagens são críticas para setores como ciência computacional, medicina e análise de dados.

A lacuna de desempenho ocorre por dois motivos principais:

1. Escassez de Dados de Pré-treinamento: Corpos de dados públicos (como o The Stack V2) são massivamente desequilibrados, contendo gigabytes de Python contra apenas gigabytes (ou menos) de outras linguagens.
2. Gargalo no Pós-treinamento: Técnicas avançadas de pós-treinamento, como Supervised Fine-Tuning (SFT) e Reinforcement Learning (RL), exigem conjuntos de dados específicos, harnesses de teste e infraestrutura de verificação para cada nova linguagem. Criar essas ferramentas manualmente para cada linguagem de baixo recurso é caro, lento e requer especialistas humanos escassos.

2. Metodologia: Agnostics

O Agnostics é um pipeline de pós-treinamento agnóstico à linguagem que elimina a necessidade de engenharia específica por linguagem. A ideia central é julgar a correção do código apenas com base em seu comportamento observável externamente (Entrada/Saída - I/O), em vez de analisar a sintaxe interna ou a estrutura do código.

O processo funciona em três etapas principais:

A. Preparação de Dados (Reformulação)

• O sistema utiliza um LLM para reformular conjuntos de dados existentes (como MBPP ou Codeforces) que originalmente possuem assinaturas de funções e testes unitários específicos de uma linguagem.
• O LLM converte esses problemas para um formato universal de I/O: o modelo deve ler dados da entrada padrão (stdin), computar uma resposta única e escrevê-la na saída padrão (stdout).
• Isso cria um formato de tarefa onde a verificação depende apenas de comparar a saída gerada com a saída esperada, independentemente da linguagem usada para gerar o código.

B. Configuração da Linguagem

• Para suportar uma nova linguagem, o usuário fornece apenas um arquivo de configuração YAML curto (4-5 linhas).
• Este arquivo define:
  1. Um prefixo de prompt (instruções para o modelo escrever em linguagem X).
  2. Comandos de shell para instalar a ferramenta de linguagem e executar o código (ex: gfortran, Rscript, luajit).
• Não é necessário escrever tradutores de testes ou compiladores personalizados complexos.

C. Treinamento com RL (Reinforcement Learning)

• O treinamento utiliza o algoritmo GRPO (Group Relative Policy Optimization), uma variante eficiente do PPO.
• Ambiente de Execução Universal: Um sandbox robusto baseado em contêineres OCI (Docker) executa o código gerado.
  • O sandbox extrai o código do bloco Markdown do modelo, compila (se necessário) e executa contra os casos de teste de I/O.
  • O sistema impõe limites de tempo (timeout) e memória para evitar loops infinitos ou consumo excessivo de recursos.
• Recompensa: O modelo recebe uma recompensa binária (1 ou 0) baseada estritamente na verificação: se a saída do programa corresponder à saída esperada nos casos de teste, a recompensa é 1; caso contrário, é 0.

3. Principais Contribuições

1. Pipeline Agnóstico: Um framework unificado que permite o treinamento de RL para qualquer linguagem de programação com apenas um arquivo de configuração YAML.
2. Novos Conjuntos de Dados: Criação de três conjuntos de dados transformados para o formato Agnostics:
   • Ag-MBPP-X (baseado em MBPP).
   • Ag-Codeforces-X (baseado em Open-R1 Codeforces).
   • Ag-LiveCodeBench-X (um novo benchmark multilíngue derivado do LiveCodeBench).
3. Modelos de Estado da Arte (SOTA) em Pequenas Escalas: Modelos abertos com ≤16B parâmetros (especificamente Qwen-3 4B e 8B) treinados com Agnostics superam modelos muito maiores (16B–70B) em linguagens de baixo recurso.
4. Framework de Execução Robusto: Uma infraestrutura de execução distribuída (usando Ray e contêineres) capaz de lidar com falhas, timeouts e erros de compilação de forma automática e escalável.

4. Resultados

Os experimentos foram realizados em cinco linguagens de baixo recurso: Lua, Julia, R, OCaml e Fortran.

• Desempenho em Modelos Pequenos:
  • O modelo Qwen-3 4B treinado com Agnostics alcançou desempenho rivalizando com modelos de 16B a 70B (como Llama 3.3 70B e Qwen 3 32B) em benchmarks como Ag-LiveCodeBench-X e MultiPL-E.
  • Em OCaml e Fortran, o modelo Qwen-3 4B melhorou de ~0-1% (acurácia base) para ~7-15%, superando até mesmo modelos de ponta (frontier models) em certas tarefas.
• Escalabilidade: O método funcionou bem em diferentes famílias de modelos, incluindo DeepSeek Coder 6.7B, Phi 4 Mini e SmolLM 3, demonstrando que não é dependente de uma arquitetura específica.
• Comparação com Outras Técnicas:
  • Vs. Distilação: O treinamento direto com RL superou a distilação de um modelo maior (Sonnet 4), que falhou em gerar dados de treinamento suficientes e de alta qualidade para essas linguagens.
  • Vs. Amostragem por Rejeição: A abordagem de Agnostics é muito mais eficiente. A amostragem por rejeição exigiria ordens de magnitude mais recursos computacionais para obter uma taxa de aceitação similar em problemas difíceis de programação competitiva.
• Análise Qualitativa: A análise de erros mostrou que o treinamento reduz drasticamente erros fundamentais (sintaxe, uso incorreto de bibliotecas, variáveis não inicializadas). Curiosamente, a taxa de erros lógicos aumentou ligeiramente, indicando que o modelo superou os erros "rasos" e agora falha apenas em problemas de lógica mais profundos.

5. Significado e Impacto

O trabalho Agnostics representa um avanço significativo na democratização da inteligência artificial para a programação.

• Redução de Custo de Engenharia: Permite que pesquisadores e desenvolvedores adaptem modelos de IA para linguagens de nicho (como Fortran para física ou R para estatística) em questão de horas, sem necessidade de especialistas nativos nessas linguagens para criar dados de treino.
• Viabilidade para Linguagens Críticas: Facilita o uso de LLMs em setores onde a precisão e o conhecimento de domínio são vitais, mas onde a tecnologia atual falha devido à falta de dados.
• Reprodutibilidade: O código, os dados e as configurações são totalmente abertos, permitindo que a comunidade estenda o suporte a qualquer linguagem que possua uma ferramenta de linha de comando para compilação e execução.

Em resumo, o Agnostics prova que, ao focar no comportamento observável (I/O) e utilizar um ambiente de execução universal, é possível superar a escassez de dados e a complexidade de engenharia, permitindo que modelos pequenos e acessíveis dominem linguagens de programação de baixo recurso.