Resumo Técnico: Além de Pares de Código: Geração de Dados Baseada em Diálogo para Tradução de Código com LLMs

Declaração do Problema

Grandes Modelos de Linguagem (LLMs) demonstraram capacidades significativas na tradução de código para linguagens populares como Python e Java. No entanto, seu desempenho deteriora-se significativamente em domínios de programação de baixo recurso (ex: Fortran) e frameworks especializados (ex: CUDA), onde dados de treinamento paralelos de alta qualidade são escassos. As abordagens existentes baseadas em agentes tipicamente seguem um fluxo de trabalho de origem-para-destino, produzindo pares de código origem-destino finais. Embora eficazes para gerar código sintaticamente válido, esses métodos descartam informações intermediárias valiosas — como erros de compilador, diagnósticos de tempo de execução e interações com ferramentas externas — que são cruciais para permitir um raciocínio mais profundo sobre a semântica do programa e o comportamento funcional. Consequentemente, modelos treinados em pares de código estáticos frequentemente falham em recuperar de erros ou gerar código funcionalmente correto em cenários de tradução complexos.

Metodologia

Os autores propõem um pipeline de geração de dataset automatizado que vai além dos tradicionais pares de código ao incorporar um design de Dual-LLM Questioner–Solver dentro de um fluxo de trabalho de tradução baseado em agentes. Esta abordagem gera diálogos de múltiplas voltas que capturam o processo de raciocínio por trás do refinamento da tradução.

O Módulo Questioner–Solver

O núcleo do sistema consiste em dois papéis distintos de LLM:

• Questioner (Questionador): Analisa o estado atual, aproveita a memória do diálogo (tentativas passadas, erros, correções) e incorpora sinais externos (erros de compilador, saídas de tempo de execução). Ele formula perguntas direcionadas, especifica restrições e verifica a consistência entre origem e destino.
• Solver (Solucionador): Executa traduções, gera testes unitários, propõe correções e retorna resultados de verificação.

Pipeline de Geração de Diálogo de Múltiplas Voltas

O pipeline processa o código da Linguagem de Programação de Origem (SPL) através das seguintes etapas para gerar diálogos verificados:

1. Pré-processamento: Filtra o código fonte para garantir que ele seja autossuficiente, executável e caiba nas janelas de contexto.
2. Geração e Verificação de Testes Unitários da SPL: O Solver gera testes unitários para o código fonte. O Questioner analisa os resultados da execução; se ocorrerem falhas, o Solver repara os testes ou o código. Este loop continua até que os testes passem (até um limite estabelecido).
3. Tradução Inicial: O Questioner solicita uma tradução para a linguagem de destino, e o Solver produz o código inicial.
4. Verificação e Refinamento da Tradução: O código traduzido é compilado e executado contra os testes unitários. O Questioner avalia os resultados e instrui o Solver a refinar a tradução com base nos erros. Este loop iterativo captura trajetórias de resolução de problemas.
5. Verificação Duo-Test: Uma etapa final garante a equivalência funcional entre os programas de origem e o traduzido, comparando as saídas. Traduções bem-sucedidas e seus históricos de diálogo completos são armazenados como dados verificados.

Construção do Dataset

O pipeline produz dois tipos de formatos de dados para ajuste fino (fine-tuning):

• Nível de Diálogo (Dialogue-Level): Conversas completas de múltiplas voltas capturando todo o fluxo de trabalho.
• Pares de Pergunta–Solução (QS Pairs): Trocas atômicas extraídas de diálogos, decompondo o raciocínio em etapas granulares.

Os autores instanciaram este pipeline para duas tarefas: Fortran→C++ e C++→CUDA, gerando 3,64k e 3,93k diálogos, respectivamente. Estes foram posteriormente decompostos em mais de 14,1k (Fortran→C++) e 12,7k (C++→CUDA) pares QS.

Principais Contribuições

1. Pipeline de Geração de Diálogo Automatizado: Um framework impulsionado por um módulo dual-LLM Questioner–Solver que integra conhecimento externo (compiladores, runtimes) em traços de raciocínio estruturados, indo além de pares de código estáticos.
2. Novos Benchmarks de Tradução: Datasets de grande escala de traduções verificadas com testes unitários para Fortran→C++ e C++→CUDA, acompanhados de três suítes de teste disjuntas para avaliação rigorosa.
3. Validação de Estratégias de Estruturação de Dados: Os autores demonstram que diferentes formatos de dados otimizam para diferentes tarefas. Decompor diálogos em QS-Pairs granulares é altamente eficaz para dominar a complexidade sintática, enquanto usar o traço de Diálogo completo é superior para preservar a correção semântica.

Resultados Experimentais

Os autores avaliaram a abordagem ajustando modelos de pesos abertos de médio porte (CodeLlama-13B, DeepSeek-Coder-6.7B, Qwen2.5-7B) nos dados gerados.

• Corretude Funcional: O ajuste fino nos dados gerados rendeu melhorias dramáticas. Na desafiadora tarefa C++→CUDA, a taxa de sucesso de teste unitário do modelo CodeLlama-13B aumentou de 12,5% para 68,8% (um aumento de >56%) quando treinado com dados de QS-Pair. Da mesma forma, a tradução Fortran→C++ viu o CodeLlama-13B melhorar de 42,3% para 74,1%.
• Ganhos de Rodadas de Debug: Modelos treinados em dados de diálogo mostraram melhorias consistentes através de múltiplas rodadas de debug, superando modelos treinados em pares de código estáticos em termos de sucesso de compilação, execução e testes unitários.
• Competitividade com Sistemas Proprietários: Um modelo Qwen2.5-7B ajustado via diálogo superou significativamente sistemas proprietários maiores (Gemini 2.5 Flash, Llama 4 Scout 17B) em métricas chave como sucesso de compilação e execução, destacando a eficiência de custo da supervisão centrada em diálogo.
• Scores de CodeBLEU: Os modelos ajustados demonstraram melhorias consistentes nos scores de CodeBLEU, indicando melhor alinhamento sintático e estrutural com as soluções de referência.

Significância

O artigo afirma que a supervisão impulsionada por diálogo melhora consistentemente a corretude funcional em várias famílias de modelos de pesos abertos, particularmente em domínios de baixo recurso onde corpora paralelos tradicionais não estão disponíveis. Ao incorporar o raciocínio estruturado (feedback do compilador, etapas de correção de erro) nos dados, a abordagem permite que os LLMs aprendam não apenas o resultado final da tradução, mas o processo pelo qual a corretude é alcançada. Os resultados sugerem que este método fornece um caminho de custo-benefício para alcançar desempenho de estado da arte na modernização de código legado, permitindo que modelos menores de pesos abertos rivalizem ou excedam sistemas proprietários maiores. Os autores observam que, embora o framework foque na corretude funcional como um primeiro passo necessário, trabalhos futuros visarão incorporar métricas de avaliação conscientes de performance.