Melhorando a Geração de Código para Linguagens Específicas de Domínio

Nos últimos anos, criar código a partir de linguagem natural melhorou bastante, principalmente com a ajuda de grandes modelos de linguagem (LLMs). Embora esses modelos tenham se tornado melhores em gerar código em linguagens de programação comuns como Python, C++ e Java, eles ainda enfrentam desafios ao lidar com Linguagens Específicas de Domínio (DSLs). As DSLs são linguagens especializadas feitas para tarefas específicas, e muitas usam nomes de funções personalizados. Quando os LLMs tentam gerar código com esses nomes personalizados, eles costumam cometer erros, resultando em saídas imprecisas. Além disso, como os nomes das funções mudam frequentemente, fica ainda mais difícil para esses modelos acompanharem.

Este artigo explora métodos para melhorar a geração de código para DSLs. Focamos em uma técnica chamada Geração Aumentada por Recuperação (RAG). Essa técnica combina o poder de gerar texto com a capacidade de recuperar informações relevantes para melhorar o processo. Comparamos os resultados do uso do RAG com um método conhecido como Ajuste fino, onde um modelo LLM é treinado em dados específicos para melhorar seu desempenho.

#O que são Linguagens Específicas de Domínio?

Linguagens específicas de domínio são feitas para aplicações particulares. Por exemplo, SQL é comumente usado para consultas em bancos de dados, enquanto outras indústrias têm suas linguagens especializadas, muitas vezes representadas em formatos como JSON ou YAML. Em nosso estudo, analisamos como gerar DSLs especificamente voltadas para automatizar tarefas em uma ampla gama de interfaces de programação de aplicativos (APIS). Essas tarefas de automação incluem coisas como lidar com faturas ou integrar leads de vendas.

Em nossos experimentos, focamos em sequências de chamadas de API que refletem fluxos de trabalho que os usuários querem automatizar. O modelo que desenvolvemos visa representar essas chamadas de API como funções. Para manter as coisas gerenciáveis, limitamos o número de chamadas de API em uma sequência a cinco, embora planejemos explorar sequências mais longas depois.

#Desafios na Geração de Código

Os métodos existentes para criar código a partir de linguagem natural enfrentam vários obstáculos. Muitos desses problemas vêm da complexidade e singularidade dos nomes personalizados de API e das constantes mudanças no cenário de APIs. Por causa disso, métodos tradicionais de ajuste fino que funcionam bem para linguagens de uso geral têm dificuldades ao serem aplicados às DSLs. As técnicas atuais muitas vezes não conseguem fundamentar o modelo com informações de API atualizadas.

Para resolver isso, propomos um sistema de ponta a ponta que combina técnicas de RAG com um LLM especificamente ajustado para geração de DSL. Essa abordagem também integra contexto adicional útil, como definições de funções para as APIs que estão sendo usadas. Ao melhorar a forma como esses modelos utilizam contexto e exemplos, queremos aumentar a qualidade do código gerado para DSLs.

#A Importância do Fundamentar

Fundamentar se refere a fornecer ao modelo contexto relevante e detalhado para ajudá-lo a tomar melhores decisões. No nosso caso, isso significa fornecer ao modelo definições de função claras e descrições das APIs. Também incorporamos um método de seleção dinâmica de exemplos baseado em saídas de código bem-sucedidas anteriores. Ao fazer isso, acreditamos que podemos melhorar a capacidade do modelo de produzir código preciso.

Coletamos um conjunto de dados abrangente contendo exemplos de prompts em linguagem natural emparelhados com suas saídas de DSL correspondentes. Esse conjunto de dados nos permite testar e refinar nossos modelos de forma eficaz.

#Arquitetura do Sistema

Nossa arquitetura de sistema proposta para gerar DSLs incorpora vários componentes que alimentam o método RAG. A arquitetura se concentra em garantir que o modelo recupere os trechos de código corretos e os nomes das funções usando um mecanismo de busca eficiente. Utilizamos mapeamento semântico para conectar as consultas em linguagem natural com exemplos de código relevantes.

Primeiro, treinamos um modelo LLM básico usando um grande conjunto de exemplos de linguagem natural e DSL. A partir desse ponto de partida, refinamos o modelo ainda mais usando abordagens RAG. Ao fazer isso, garantimos ajustar o modelo enquanto também o fundamentamos com o contexto relevante da API, o que ajuda a gerar saídas mais precisas e relevantes.

#Ajuste Fino vs. RAG

Ajuste fino é uma estratégia comum onde um modelo pré-treinado é adaptado a novas tarefas treinando-o em um conjunto de dados específico. Embora essa abordagem funcione bem para tarefas de programação convencionais, ela pode deixar espaço para melhorias quando se trata de DSLs. A técnica RAG, por outro lado, permite que o modelo puxe informações dinamicamente, ajudando-o a se manter atualizado com novas mudanças de API sem exigir um re-treinamento extenso.

Em nossos experimentos, medimos a eficácia dos métodos de ajuste fino e RAG. Avaliamos seus desempenhos através de uma série de métricas projetadas para avaliar a correção do código, semelhança com a verdade de base e taxas de erros ou imprecisões nas saídas geradas.

#Geração de Dados e Métricas

Para testar nossos modelos, criamos um conjunto de dados com milhares de pares de linguagem natural e DSL. Cada par reflete a intenção de um usuário de automatizar uma tarefa com chamadas de API específicas. Esse conjunto de dados é crucial para treinar os modelos e avaliar seu desempenho.

Definimos três métricas principais:

1. Semelhança Média: Essa métrica mede quão de perto a DSL gerada corresponde ao fluxo correto esperado de chamadas de API.

2. Taxa de Não Análise: Essa métrica rastreia com que frequência o código gerado não pode ser compreendido corretamente por um analisador, indicando erros de sintaxe.

3. Taxa de Alucinação: Essa mede com que frequência o modelo produz nomes ou chaves para APIs que não existem, levando a saídas de código potencialmente erradas.

Ao monitorar essas métricas, podemos quantificar e comparar a eficácia do modelo ajustado com a abordagem baseada em RAG.

#Resultados e Comparações

Nossos testes revelam insights interessantes sobre o desempenho do RAG em comparação com o ajuste fino. Enquanto o ajuste fino se mostra eficaz em gerar menos alucinações, frequentemente resulta em taxas mais altas de erros de sintaxe. Por outro lado, o RAG demonstra uma capacidade mais forte de manter a sintaxe correta, apesar de ter uma taxa ligeiramente aumentada de nomes de funções incorretos.

Observamos que a seleção dinâmica de exemplos aumenta significativamente o desempenho do modelo, sugerindo que fundamentar com contexto relevante desempenha um papel vital no processo de geração. Modelos que incorporam aprendizado com poucos exemplos, com os exemplos certos, levam a melhores resultados, reduzindo as taxas de alucinação para nomes e parâmetros de API.

Quando comparamos o uso de definições de funções de API junto com as amostras geradas versus o uso apenas de definições semânticas, descobrimos que o primeiro sempre resulta em melhores resultados. Isso sugere que definições claras ajudam o modelo a entender melhor sua tarefa, levando a saídas mais precisas.

#Conclusão

Em conclusão, nosso estudo ilustra o potencial de combinar técnicas RAG com modelos ajustados para aprimorar a geração de DSL a partir de prompts em linguagem natural. Embora o ajuste fino continue sendo forte em reduzir erros relacionados a nomes alucinatórios, a adaptabilidade do RAG o torna uma alternativa atraente, especialmente ao trabalhar com APIs que mudam constantemente. Através da seleção cuidadosa de exemplos e do fundamentar com contexto relevante de API, conseguimos alcançar melhorias significativas na qualidade da geração de código.

Nossas descobertas indicam que ambos os métodos têm valor, e uma exploração mais aprofundada em abordagens combinadas pode resultar em resultados ainda melhores. A capacidade de se adaptar rapidamente a novas APIs continua sendo uma prioridade para o trabalho futuro, pois permitirá melhorias contínuas na qualidade do código gerado a partir da linguagem natural, tornando o processo mais eficiente e confiável para os usuários.