Desafios das APIs Obsoletas na Completação de Código em LLM

Modelos de linguagem grandes (LLMs) são programas de computador que conseguem criar código com base em comandos dados. Esses modelos foram treinados com uma porção enorme de dados de programação, o que os torna bem eficazes em sugerir finalizações de código. No entanto, um grande problema surge quando esses modelos usam códigos ou funções desatualizados, conhecidos como APIs depreciadas. À medida que bibliotecas ou frameworks que os desenvolvedores usam evoluem, algumas funções e métodos ficam obsoletos e são substituídos por outros mais novos. Essa mudança pode atrapalhar o desempenho dos LLMs, especialmente quando eles sugerem código antigo que pode não funcionar direito.

As atualizações e mudanças rápidas nas bibliotecas de programação resultam em mudanças contínuas no que é considerado código válido ou recomendado. Então, é essencial examinar com que frequência esses modelos sugerem APIs depreciadas e o que causa isso. Este relatório tem como objetivo detalhar esse problema e oferecer formas de melhorar a situação nos ambientes de programação.

#O Problema com APIs Depreciadas

Ao desenvolver software, os programadores costumam contar com bibliotecas de terceiros, que são coleções de código pré-escrito que oferecem funções úteis. Cada biblioteca tem um conjunto de regras, chamadas de Interfaces de Programação de Aplicativos (APIs), que orientam como interagir com elas. Com o tempo, as bibliotecas passam por atualizações onde funções antigas podem se tornar depreciadas. Uma função depreciada é aquela que não é mais recomendada para uso e pode ser removida em atualizações futuras.

Por exemplo, em uma biblioteca popular para aprendizado profundo chamada PyTorch, uma função foi removida e substituída por outra. À medida que as bibliotecas melhoram, elas podem substituir funções mais antigas por outras que têm melhor desempenho ou oferecem novos recursos. Usar APIs depreciadas pode causar problemas no código, já que elas podem não funcionar bem com designs ou dados mais novos, levando a possíveis bugs nos projetos de software.

Apesar do uso crescente de LLMs na programação, as pesquisas sobre com que frequência esses modelos usam APIs depreciadas são limitadas. Estudos anteriores focaram principalmente na precisão geral desses modelos, mas não avaliaram especificamente como eles evitam código desatualizado ao sugerir finalizações.

#Objetivos da Pesquisa

O principal objetivo deste estudo é investigar a frequência e as razões por trás do uso de APIs depreciadas nos LLMs ao realizar finalizações de código. Para isso, traçamos algumas perguntas de pesquisa:

1. Qual é o estado atual do uso de APIs depreciadas na finalização de código baseada em LLM?
2. Que papel diferentes tipos de comandos desempenham nas previsões feitas pelos LLMs sobre APIs depreciadas?
3. Como a escolha das bibliotecas influencia o uso de APIs depreciadas pelos LLMs?

Respondendo a essas perguntas, esperamos entender melhor as razões para o uso de APIs depreciadas e explorar soluções para melhorar o desempenho dos LLMs na Geração de Código.

#Metodologia

Para mergulhar nesse problema, fizemos um estudo detalhado usando vários LLMs e bibliotecas de codificação amostrais. Focamos em oito bibliotecas populares de Python que são amplamente usadas na comunidade de programação, incluindo tanto manipulação de dados quanto frameworks de aprendizado de máquina. Isso nos deu um conjunto diversificado de APIs para analisar.

#Coleta de Dados

Coletamos dados sobre um total de 145 APIs depreciadas e suas substituições das bibliotecas escolhidas. Isso envolveu revisar a documentação oficial e os logs de atualização de cada biblioteca para identificar quais APIs foram depreciadas e quais eram suas substituições. No total, reunimos 9.022 instâncias de uso de APIs depreciadas e 19.103 instâncias de suas substituições.

#Experimentação

Para avaliar como os LLMs lidam com sugestões de APIs depreciadas, criamos comandos específicos. Cada comando foi construído em torno de funções que usavam APIs depreciadas ou suas substituições. Em seguida, alimentamos esses comandos em sete LLMs avançados para ver como eles respondiam.

Por exemplo, se um comando continha uma função depreciada, verificaríamos se o modelo sugeriria essa função ou sua substituição. Nossa análise nos ajudaria a entender a capacidade dos modelos de evitar sugestões desatualizadas e se seu desempenho mudava com base nos comandos ou nas bibliotecas usadas.

#Avaliando os Resultados

Uma vez que coletamos os dados, avaliamos de algumas maneiras diferentes:

#Desempenho do Modelo

Descobrimos que todos os LLMs que testamos enfrentaram desafios em prever o uso das APIs corretas. Geralmente, os modelos se saíram melhor ao prever funções novas em comparação com as desatualizadas. Isso indica que, embora os LLMs possam ser úteis para finalizações de código, eles muitas vezes são enganados pela presença de APIs depreciadas em seus dados de treinamento.

#Influência do Comando

O tipo de comandos que alimentamos nos LLMs afetou significativamente seu desempenho. Para comandos que se referiam a funções usando APIs depreciadas, os modelos tendiam a sugerir aquelas funções desatualizadas em vez de suas substituições. Por outro lado, comandos derivados de funções que utilizavam APIs atualizadas mostraram uma maior probabilidade de os modelos sugerirem as APIs corretas e mais novas. Isso sugere que o contexto dos comandos é crucial para orientar as sugestões dos modelos.

#Variação da Biblioteca

Diferentes bibliotecas tiveram influências variadas sobre como os LLMs sugeriam APIs. Algumas bibliotecas tiveram transições mais claras de APIs antigas para novas, enquanto outras causaram confusão. Isso foi particularmente evidente em bibliotecas que mudaram suas APIs levemente sem alterar seus padrões de uso. Nesses casos, os modelos às vezes sugeriam as APIs depreciadas simplesmente porque não conseguiam diferenciar entre as versões antigas e novas.

#Soluções Propostas

Para lidar com o problema do uso de APIs depreciadas, propomos duas estratégias simples para ajudar os LLMs a oferecerem melhores finalizações de código. Essas estratégias visam abordar os desafios discutidos acima, melhorando a forma como os modelos processam o conhecimento sobre APIs depreciadas.

#Abordagem ReplaceAPI

A primeira solução, chamada ReplaceAPI, funciona substituindo diretamente qualquer instância de uma API depreciada no código sugerido. Quando o modelo prevê uma função depreciada, essa abordagem a substitui pela sua substituição e gera o resto do código com base nessa mudança. Esse método simples pode ajudar a garantir que apenas APIs atualizadas sejam propostas.

#Abordagem InsertPrompt

A segunda abordagem, InsertPrompt, envolve adicionar um comando extra que instrui o modelo a usar a nova API enquanto gera o código. Ao adicionar essa instrução adicional diretamente no comando, o modelo é orientado a favorecer a função correta em vez das depreciadas. Esse método foca em refinar o contexto em que o modelo faz suas previsões.

#Avaliação das Soluções

Realizamos testes para ver como nossas estratégias propostas abordaram o problema do uso de APIs depreciadas. O desempenho de cada abordagem foi medido usando várias métricas:

1. Taxa de Correção (FR): A porcentagem de finalizações que usaram com sucesso as APIs corretas após a aplicação de nossas estratégias.
2. Semelhança de Edição (ES): O quão próximo as sugestões estavam do código correto com base nas edições necessárias.
3. Correspondência Exata (EM): A porcentagem de finalizações que corresponderam exatamente ao código correto.

#Resultados da ReplaceAPI

Nossa estratégia ReplaceAPI gerou resultados promissores. Todos os LLMs alcançaram altas taxas de correção, frequentemente superando 85%. Isso significa que os modelos conseguiram corrigir um número substancial de suas próprias sugestões depreciadas quando instados a fazê-lo. As edições sugeridas também eram razoavelmente precisas, demonstrando a capacidade de manter a qualidade do código enquanto corrigiam referências de APIs desatualizadas.

#Resultados da InsertPrompt

A abordagem InsertPrompt mostrou mais variabilidade no desempenho. Enquanto alguns modelos se saíram bem, outros tiveram dificuldades em interpretar o comando inserido de forma efetiva. Os modelos que tiveram melhor desempenho, particularmente os maiores, mostraram uma forte capacidade de adaptar suas respostas com base nas instruções adicionais. Apesar disso, nem todos os modelos conseguiram usar as novas APIs corretamente de forma consistente, destacando a necessidade de mais refinamento na engenharia de comandos.

#Conclusão

Este estudo de avaliação destaca os desafios que os LLMs enfrentam ao sugerir finalizações de código, especialmente em relação ao uso de APIs depreciadas. Nossas descobertas indicam que esses modelos muitas vezes utilizam funções desatualizadas devido ao seu treinamento em dados de programação mais antigos e ao contexto proporcionado por comandos específicos.

Ao entender as causas por trás desse problema, podemos trabalhar para desenvolver melhores ferramentas de geração de código. Nossas estratégias propostas, ReplaceAPI e InsertPrompt, mostraram potencial em guiar os LLMs a sugerir APIs mais atualizadas. Os próximos passos envolvem refinar ainda mais essas abordagens e explorar métodos adicionais para criar ferramentas de codificação mais confiáveis.

À medida que a programação continua a evoluir, garantir que as sugestões de código permaneçam relevantes e funcionais será crucial para os desenvolvedores. Ao abordar proativamente o problema das APIs depreciadas, podemos melhorar a confiabilidade da finalização de código impulsionada por LLM e contribuir para práticas de desenvolvimento de software mais eficientes.