RepoExec: Um Novo Benchmark para Modelos de Geração de Código

A geração de código se tornou uma área importante no desenvolvimento de software, especialmente com o crescimento dos grandes modelos de linguagem (LLMs) que ajudam a automatizar tarefas de codificação. No entanto, a capacidade desses modelos de gerar código completo e funcional em todo um projeto ainda não foi amplamente testada. Este artigo apresenta uma nova referência chamada RepoExec, que tem como objetivo avaliar quão bem os modelos de geração de código conseguem criar código executável e correto no nível do repositório.

#Desafios na Geração de Código

Muitas referências existentes focam em gerar código para funções individuais, em vez de considerar como essas funções trabalham juntas em um projeto. Essa limitação pode levar a um código gerado que não está alinhado com a forma como toda a base de código deveria funcionar. Modelos de geração de código frequentemente perdem contextos importantes de arquivos relacionados, o que pode resultar em saídas imprecisas ou incompletas.

Para entender as verdadeiras capacidades desses modelos, precisamos avaliá-los na geração de código a nível de repositório, focando em três aspectos principais:

1. Executabilidade: O código gerado deve não apenas estar correto em termos de sintaxe, mas também funcionar com sucesso em um ambiente real.
2. Corretude funcional: O código gerado deve atender aos requisitos especificados no projeto, comprovados por testes que abrangem uma ampla gama de cenários.
3. Uso de dependências: Os modelos devem levar em conta com precisão as dependências necessárias para o código, garantindo que utilizem os contextos fornecidos de forma eficaz.

#Referências Existentes e Suas Limitações

As referências atuais, como RepoBench, RepoCoder, CrossCodeEval, CoCoMIC e DevEval, fornecem uma visão sobre o desempenho da geração de código. No entanto, elas têm limitações significativas:

• Não garantem que o código gerado seja executável em ambientes do mundo real.
• Frequentemente usam métodos básicos para recuperar informações contextuais, resultando em dados ruidosos que podem prejudicar o desempenho dos sistemas de geração de código.
• Não focam em verificar se o código gerado entende e incorpora corretamente as dependências fornecidas pelos desenvolvedores.

#Apresentando o RepoExec

O RepoExec foi projetado para enfrentar esses desafios, fornecendo uma reflexão mais precisa dos cenários de codificação do mundo real. Seu foco principal é:

• Executabilidade aprimorada: O RepoExec verifica se o código gerado é sintaticamente correto e executável em ambientes do mundo real. Um sistema automatizado verifica requisitos de instalação e tempo de execução.

• Geração dinâmica de casos de teste: O RepoExec incorpora mecanismos avançados para criar casos de teste que garantem que o código gerado funcione como previsto. Esses testes são personalizados para corresponder à funcionalidade do código gerado e manter uma alta taxa de cobertura.

• Avaliação do uso de dependências: O RepoExec avalia quão bem os modelos lidam com as dependências do código, fornecendo insights detalhados sobre como essas dependências são usadas. Ele também introduz um novo conjunto de dados que foca em chamadas de dependência, ajudando os modelos a aprenderem a utilizá-las corretamente.

Além disso, o RepoExec introduz uma nova métrica chamada Taxa de Invocação de Dependência (DIR). Essa métrica mede quão bem o código gerado incorpora as dependências fornecidas. Uma pontuação DIR mais alta indica que o modelo entende e usa as dependências de forma eficaz.

#Experimentos e Descobertas

Os experimentos realizados com o RepoExec revelaram insights importantes sobre os modelos de geração de código. Os resultados mostraram que, enquanto alguns modelos pré-treinados conseguiam gerar código que funcionava corretamente, modelos ajustados por instruções demonstraram um desempenho mais forte na gestão de dependências e depuração.

• Modelos pré-treinados se destacaram em gerar código que passou nos testes iniciais, mas frequentemente tinham dificuldades em aproveitar dependências.
• Modelos ajustados por instruções conseguiram incluir dependências de forma mais eficaz, mas às vezes produziam código excessivamente complexo.

Testes de depuração em múltiplas rodadas mostraram que modelos como GPT-3.5 e WizardCoder melhoraram significativamente seu desempenho após a aplicação desse método, aumentando tanto a correção de seu código quanto sua capacidade de utilizar dependências.

#O Processo de Coleta de Dados

Para construir o RepoExec, foi estabelecido um pipeline sistemático de coleta de dados. Esse processo se concentrou em garantir que os repositórios pudessem ser configurados para ambientes executáveis, o que é essencial para uma verdadeira avaliação.

1. Extração de Funções e Dependências: O repositório é analisado para extrair funções consideradas adequadas para a geração de código a nível de repositório. Uma ferramenta chamada tree-sitter é utilizada para quebrar arquivos e identificar funções e suas dependências.

2. Geração de Casos de Teste: Dado que muitos repositórios não têm testes suficientes, LLMs automatizados são usados para criar casos de teste. Esses testes gerados são filtrados quanto à correção e relevância com base em vários critérios, garantindo que avaliem com precisão a funcionalidade do código gerado.

#Avaliando o Desempenho dos Modelos

O RepoExec emprega dois tipos de prompts para avaliar os modelos, variando a quantidade de informações contextuais fornecidas:

• BasePrompt: Isso inclui todo o contexto e dependências disponíveis, permitindo que o modelo utilize a informação completa do repositório.

• InstructPrompt: Esse formato inclui instruções específicas para os modelos, projetadas para orientá-los na geração de código de forma eficaz.

Na avaliação de diferentes modelos como Codellama, foi constatado que manter o contexto completo resultou no melhor desempenho. No entanto, usar contextos menores às vezes levou a melhores resultados porque reduziu a confusão na interpretação das dependências.

#Resultados Entre Diferentes Modelos

O RepoExec foi testado em 13 modelos diferentes de geração de código. Os resultados revelaram uma descoberta crítica: enquanto modelos base atingiram alta precisão, modelos ajustados por instruções se destacaram na gestão eficaz de dependências. No entanto, ambos os tipos de modelos tinham limitações:

• Modelos ajustados por instruções frequentemente produziam implementações excessivamente complexas e nem sempre aproveitavam as dependências corretamente.
• Modelos pré-treinados frequentemente geravam saídas corretas, mas não conseguiam reutilizar as dependências fornecidas, levando a um código redundante.

Esses resultados sugerem que os modelos podem ter dificuldades em produzir código de alta qualidade, requerendo uma revisão e correção manuais substanciais.

#Utilizando Depuração em Múltiplas Rodadas

Para refinar ainda mais a qualidade do código gerado, foi empregada a depuração em múltiplas rodadas. Isso envolve reexecutar o código gerado anteriormente várias vezes, analisando logs de erro e corrigindo erros. Em testes, GPT-3.5 e WizardCoder mostraram melhorias promissoras tanto na correção quanto na utilização de dependências após três rodadas de depuração.

#Ajuste de Instruções para Melhor Desempenho

Para facilitar um melhor uso das dependências e melhorar a correção das saídas, foi desenvolvido um conjunto de dados para ajuste de instruções. Esse conjunto foi criado a partir de repositórios de código populares e incluía um número significativo de funções e suas dependências.

A afinação nesse conjunto de dados levou a melhorias marcantes no desempenho do modelo. Após o ajuste por instruções, os modelos demonstraram melhores taxas de aprovação e DIR, indicando uma maior compreensão da gestão de dependências e funcionalidade.

#Conclusão e Trabalho Futuro

O RepoExec serve como uma ferramenta valiosa para avaliar o desempenho dos modelos de geração de código a nível de repositório. Ao focar em executabilidade, corretude funcional e uso de dependências, ele fornece uma representação mais precisa das tarefas de codificação do mundo real.

Embora os modelos pré-treinados se destaquem em gerar código correto, os modelos ajustados por instruções mostram potencial em entender dependências, embora com alguns desafios. O trabalho futuro pode focar em refinar ainda mais esses modelos, talvez integrando múltiplos níveis de contextos de dependência para aprimorar sua compreensão de interações complexas de software.

À medida que o campo da geração de código evolui, referências como o RepoExec podem guiar o desenvolvimento de modelos mais capazes, garantindo que atendam às necessidades do desenvolvimento de software do mundo real.