Resumo Técnico: Pré-treinamento de Código Contextualizado para Geração de Código

1. Declaração do Problema

Os modelos modernos de geração de código são predominantemente treinados e avaliados em funções isoladas acompanhadas de descrições em linguagem natural (por exemplo, HumanEval, MBPP). No entanto, no desenvolvimento de software do mundo real, as funções raramente são implementadas de forma isolada. Os desenvolvedores tipicamente escrevem primeiro a lógica de controle de alto nível, que então invoca funções utilitárias de baixo nível que ainda não foram implementadas. Nestes cenários, o contexto de chamada (o código que invoca a função alvo) fornece pistas acionáveis sobre o comportamento esperado, formas de dados e requisitos de tratamento de erros que frequentemente estão ausentes nas descrições em linguagem natural ou nas assinaturas de função.

As abordagens existentes para geração de código em nível de repositório dependem principalmente de recuperação no momento da inferência (por exemplo, RepoCoder, GraphCoder) para buscar contexto relevante. Esses métodos tratam o contexto como um recurso externo a ser recuperado e anexado aos prompts. Eles enfrentam limitações quando:

1. Não existem trechos de código semelhantes no repositório (funcionalidade nova).
2. A recuperação falha em trazer à tona o contexto correto devido a problemas de indexação ou classificação.
3. O modelo não é explicitamente treinado para interpretar e aproveitar as restrições semânticas impostas pelo chamador.

Consequentemente, os modelos atuais frequentemente geram código que satisfaz uma descrição funcional, mas falha em integrar-se suavemente com o uso circundante, levando a implementações que não aderem aos contratos implícitos estabelecidos pelo chamador.

2. Metodologia

Os autores propõem o Pré-treinamento de Código Contextualizado, um framework consciente de invocação que integra o contexto de chamada diretamente no objetivo de pré-treinamento dos modelos de código. A abordagem consiste em três componentes principais:

A. Construção de Dataset Consciente de Invocação

Os autores desenvolveram um pipeline automatizado de análise estática para extrair pares chamador–chamado em larga escala de repositórios Python do mundo real.

• Extração: Usando o módulo ast do Python, o sistema analisa arquivos de origem para construir um grafo de chamadas bidirecional. Ele identifica funções alvo e extrai os corpos completos de seus chamadores diretos como o "contexto consciente de invocação".
• Filtragem: Para garantir qualidade, os autores filtraram 800 repositórios com base na popularidade, status de manutenção e diversidade estrutural. Eles excluíram conjuntos de dados algorítmicos, código relacionado a testes e funções incompletas.
• Construção: O corpus final contém 235.460 funções alvo únicas. Cada instância de treinamento emparelha uma função alvo com seu cabeçalho, um trecho de código de um chamador direto e a docstring em linguagem natural da função alvo (se disponível). Se uma função tiver múltiplos chamadores, cada par chamador-chamado é tratado como uma instância de treinamento distinta.

B. Objetivo de Pré-treinamento (CallerGen)

Os autores introduzem o CallerGen, uma família de modelos pré-treinados com um objetivo consciente de invocação. A tarefa de treinamento condiciona a geração do corpo da função alvo a três entradas:

1. O cabeçalho da função (assinatura).
2. O trecho de código de um chamador direto (o contexto de chamada).
3. A docstring em linguagem natural.

O modelo aprende a maximizar a probabilidade de gerar o corpo da função correto dadas essas pistas contextuais. Esta abordagem foi aplicada a duas arquiteturas:

• Codificador-Decodificador: CodeT5-small (60M) e CodeT5-base (220M).
• Apenas Decodificador: Qwen2.5-Coder-0.5B.

C. Benchmark: CallerEval

Para avaliar os modelos sob condições realistas, os autores construíram o CallerEval, um novo benchmark com 263 tarefas de geração em nível de função.

• Design: As tarefas são extraídas de repositórios distintos do conjunto de treinamento para evitar vazamento de dados. Cada tarefa inclui a função alvo, seus chamadores do mundo real e uma suíte de testes comportamentais.
• Construção de Testes: Como muitas funções alvo carecem de testes unitários existentes, os autores projetaram um protocolo para reconstruir testes comportamentais leves. Esses testes são derivados dos padrões de uso observados nos chamadores (por exemplo, como os valores de retorno são acessados ou como as exceções são tratadas), garantindo que a avaliação reflita o "contrato" imposto pelo chamador.
• Avaliação: O desempenho é medido usando Pass@k (correção funcional via execução) e métricas estáticas (CodeBLEU, ROUGE-L).

3. Principais Contribuições

1. Formalização da Tarefa: O artigo formaliza a "geração de código com contextos de chamada" como uma configuração de tarefa distinta, enfatizando que os contextos de chamada são sinais críticos para guiar a implementação em cenários realistas de desenvolvimento.
2. Modelo CallerGen: Os primeiros modelos de código pré-treinados com objetivos conscientes de invocação. O CallerGen é o primeiro a condicionar explicitamente a geração em contextos de chamada durante a fase de pré-treinamento, em vez de depender exclusivamente da recuperação no momento da inferência.
3. Benchmark CallerEval: Um novo benchmark projetado para avaliar modelos sob cenários dirigidos por chamadores, apresentando pares chamador-chamado realistas e protocolos de teste conscientes de comportamento que vão além de simples descrições funcionais.
4. Avaliação Abrangente: Experimentos extensivos demonstrando que o treinamento consciente de invocação melhora o desempenho em diferentes escalas e arquiteturas de modelos, particularmente em cenários onde o contexto de chamada está disponível.

4. Resultados Experimentais

Os autores avaliaram o CallerGen contra nove baselines de última geração (incluindo CodeGen, PanGu-Coder, DeepSeek-Coder e Qwen-Coder) tanto no benchmark público CoderEval quanto no novo CallerEval.

Desempenho em Configurações com Chamador Disponível

• O CallerGen superou consistentemente baselines de tamanho similar. Por exemplo, o CallerGen-base (220M) alcançou 16,58% Pass@1 no CallerEval com entradas completas (Cabeçalho + Chamador + NL), superando significativamente o CodeGen-350M (8,97%) e o PanGu-300M (11,79%).
• O CallerGen-qwen (0.5B) alcançou 22,81% Pass@1 no CallerEval, superando o Qwen2.5-Coder-0.5B-Instruct ajustado para instruções (6,16%) por uma grande margem e estreitando a lacuna com modelos muito maiores (por exemplo, Qwen2.5-Coder-32B-Instruct em 20,99%).
• Os modelos mostraram maior robustez; a queda de desempenho ao passar do CoderEval mais fácil para o CallerEval mais difícil foi significativamente menor para o CallerGen do que para as baselines.

Desempenho em Configurações sem Chamador

• Mesmo sem contexto de chamada (Apenas Cabeçalho ou Cabeçalho + NL), o CallerGen permaneceu competitivo, frequentemente igualando ou superando modelos de tamanho similar. Por exemplo, o CallerGen-0.5B alcançou 13,92% Pass@1 no CallerEval (Cabeçalho + NL), superando o Qwen2.5-Coder-0.5B-Instruct (9,13%).
• No entanto, os autores observam que todos os modelos experimentaram uma queda de desempenho em configurações sem chamador, destacando que o contexto de chamada é um componente crucial para geração de alta qualidade.

Ablação e Análise

• Semântica vs. Comprimento: Estudos de ablação revelaram que os ganhos provêm de evidência semântica (como o valor de retorno é usado, fluxo de controle ao redor da chamada) e não simplesmente do aumento do comprimento do prompt. Substituir o contexto do chamador por código irrelevante do mesmo comprimento resultou em desempenho inferior.
• Supervisão Multi-Chamador: O treinamento com múltiplos chamadores por função melhorou a capacidade do modelo de utilizar evidências do chamador no momento da inferência, sugerindo que o modelo aprende a reconciliar restrições de uso diversas.

5. Significado e Alegações

O artigo alega que os contextos de chamada são uma fonte rica e confiável de intenção semântica que são atualmente subutilizados na geração de código. Ao tratar o contexto de chamada como um sinal de condicionamento explícito durante o pré-treinamento, os modelos podem aprender a gerar código que não é apenas funcionalmente correto, mas também coerente comportamentalmente com seu ambiente de uso.

Os autores argumentam que, embora a recuperação no momento da inferência (aumentar prompts com contexto) seja útil, é insuficiente se o próprio modelo não tiver aprendido a interpretar e aproveitar as restrições de invocação. O CallerGen demonstra que o pré-treinamento consciente de invocação permite que os modelos:

1. Inferam contratos comportamentais implícitos a partir do código do chamador.
2. Gerem implementações que se integram suavemente a bases de código existentes.
3. Alcançem desempenho de última geração em relação ao seu tamanho de parâmetros, frequentemente superando modelos significativamente maiores.

O trabalho conclui que incorporar contextos de chamada é essencial para avançar a geração de código em direção a cenários realistas de desenvolvimento de software em nível de repositório. Os autores reconhecem limitações, observando que seu pipeline atual é específico para Python e depende de análise estática, o que pode enfrentar desafios com recursos dinâmicos, mas eles postulam que o princípio central da geração condicionada à invocação é agnóstico à linguagem.