Melhorando a correção de bugs com sugestões do CodeT5

Programadores frequentemente enfrentam o desafio de encontrar e corrigir bugs no código. Corrigir esses erros pode levar muito tempo e ser frustrante. Nos últimos anos, surgiram modelos de linguagem projetados para ajudar programadores sugerindo correções para o código deles. Porém, esses modelos às vezes sugerem mudanças que são muito diferentes do código original, dificultando a compreensão das alterações.

Neste trabalho, focamos em um método para usar o CodeT5, um modelo de linguagem específico, para sugerir correções que exijam alterações mínimas. Ao treinar o CodeT5 com exemplos de código errado e certo, conseguimos ajudar os programadores a obter Sugestões melhores para consertar seus programas, tornando o processo mais fácil.

#A Importância das Edições Mínimas

Quando os programadores fazem alterações no código, geralmente estão editando para corrigir bugs, adicionar novas funcionalidades ou modificar funcionalidades existentes. Estudos mostram que muitas dessas edições são repetitivas e que fazê-las manualmente pode levar a erros. Os modelos de linguagem podem ajudar a reduzir essas tarefas repetitivas, fornecendo sugestões para corrigir erros.

No entanto, uma frustração com muitos modelos é que o código que eles geram muitas vezes parece bem diferente do original. Essa diferença pode levar a confusão, dificultando a compreensão das correções sugeridas. Portanto, é mais benéfico fornecer sugestões que exijam edições mínimas.

#Nossa Abordagem

Propomos uma abordagem que usa o CodeT5 para sugerir o código certo com menos mudanças. Ajustamos o CodeT5 usando pares de código errado e certo coletados de problemas de programação. Ao avaliar seu desempenho em relação a outros modelos, descobrimos que o CodeT5 apresenta resultados melhores ao sugerir correções.

Nossos testes mostraram que o CodeT5 pode sugerir com sucesso um programa correto para cerca de 91,95% dos programas errados com uma média de 6,84 edições necessárias. Isso significa que, ao gerar 100 programas candidatos, pelo menos um deles provavelmente será uma correção adequada.

#Esforços Anteriores na Reparação de Programas

A reparação automatizada de programas tem ganhado popularidade à medida que os sistemas de software continuam a crescer. Pesquisadores exploraram várias técnicas para facilitar esse processo para os programadores. Muitos desses esforços utilizam métodos de aprendizado profundo, semelhante a como máquinas traduzem idiomas.

Alguns modelos anteriores dependiam de diferentes tipos de redes neurais para fornecer sugestões para corrigir erros no código. Também houve esforços para usar técnicas como redes neurais gráficas para entender melhor a estrutura do código. No entanto, a maioria dessas abordagens não se concentrou em minimizar a quantidade de mudança necessária para corrigir os programas.

Nosso trabalho visa preencher essa lacuna, abordando especificamente a necessidade de edições mínimas ao fornecer reparos, facilitando a compreensão do usuário em relação ao código sugerido.

#Como Testamos o Modelo

Coletamos pares de código compostos por programas errados e certos de um sistema de juiz online. Cada par inclui tentativas anteriores de usuários, garantindo que nosso conjunto de dados contenha exemplos reais de erros comuns de programação e suas correções. Dividimos os dados em conjuntos de treinamento, validação e teste para avaliar o quão bem nosso modelo se sai.

Para avaliar os resultados, usamos várias métricas. A primeira medida importante é a Taxa de aprovação, que indica a porcentagem de problemas para os quais nosso modelo sugere com sucesso uma solução correta. Também olhamos quantos dos programas gerados passam na compilação, o que significa que não têm erros de sintaxe.

Em seguida, medimos quão parecidos os programas gerados são com a resposta correta usando uma métrica chamada BLEU. Isso nos ajuda a ver o quanto a saída do modelo se assemelha à solução originalmente pretendida.

Também analisamos a porcentagem de correspondência exata, que nos diz quantos dos programas gerados eram idênticos à solução correta. Finalmente, calculamos a Distância de Edição, que nos mostra quantas mudanças foram necessárias para converter o programa errado no programa correto sugerido.

#Resultados do Nosso Experimento

Nossas descobertas mostraram que o CodeT5 se saiu significativamente melhor do que outros modelos. Em nossos testes, o modelo CodeT5 sugeriu com sucesso pelo menos uma solução correta para quase 92% dos programas errados que testamos. Isso é uma melhoria substancial em comparação com alguns modelos de referência que alcançaram taxas de sucesso significativamente mais baixas.

Em termos de distância de edição, o modelo CodeT5 também teve um bom desempenho. Ele teve uma distância média de edição de 8,54, o que indica que as mudanças necessárias foram mínimas em comparação com a distância média calculada para correções feitas por humanos. Em contraste, outros modelos como Seq2Seq exigiram mudanças mais extensas, muitas vezes levando à confusão dos usuários.

O modelo Naive Copy, que simplesmente repetia a entrada, teve uma alta pontuação BLEU, mas foi completamente inútil, pois não conseguiu gerar nenhuma resposta de programa correta. Da mesma forma, o modelo Naive Retrieval, que escolheu o programa correto mais semelhante dos dados de treinamento, teve uma taxa de sucesso de 100%. No entanto, fez mudanças significativas, indicadas por uma distância de edição muito maior.

No geral, enquanto os modelos ingênuos forneceram certos benefícios, eles não corresponderam à capacidade do CodeT5 de propor reparos relevantes com mudanças mínimas.

#Conclusão

O método proposto usando o CodeT5 mostra uma abordagem promissora para reparação de programas. Ao focar em gerar reparos que exigem menos edições, podemos fornecer aos programadores soluções mais compreensíveis e funcionais para seus problemas. Essa abordagem não só ajuda a corrigir erros de codificação, mas também apoia os usuários a aprender e entender melhor a programação.

Trabalhos futuros poderiam buscar melhorar a correção geral e diminuir ainda mais as mudanças necessárias. Explorar modelos de linguagem adicionais poderia abrir novos caminhos para refinar esse processo, tornando a programação mais fácil para mais usuários a longo prazo.

Em resumo, os avanços vistos com o CodeT5 destacam o potencial dos modelos de linguagem em auxiliar programadores de forma eficaz, criando uma maneira eficiente de reparar o código enquanto minimizam a confusão e o esforço necessário.