Aprimorando o Código com Modelos de Linguagem Grandes

Melhorar e consertar código fonte usando grandes modelos de linguagem (LLMs) virou uma técnica comum pra criar Programas que seriam complexos demais de juntar tudo de uma vez. Usando um conjunto de casos de teste junto com um programa candidato, um LLM consegue melhorar esse programa, especialmente quando recebe informações sobre quais testes ele falhou.

Mas ainda não tá claro como refinar o código da melhor forma, já que métodos passados usaram estratégias bem básicas. Este trabalho destaca que refinar código envolve um equilíbrio entre explorar novas opções e aproveitar as boas que já existem. Basicamente, você pode focar em melhorar o código que já passa em vários testes ou tentar refinar programas que ainda não foram muito explorados.

A gente vê essa situação como um problema parecido com um jogo onde você escolhe entre diferentes opções, e usamos um método chamado Thompson Sampling pra resolver isso. A abordagem que desenvolvemos pode ser aplicada em várias áreas, tipo sintetizar invariantes de loop, resolver tarefas de raciocínio visual e até enfrentar problemas de competições de programação. Nosso método mostrou que consegue resolver mais problemas usando menos chamadas pro modelo de linguagem.

Uma nova forma de lidar com problemas com LLMs envolve fazer com que eles corrijam, consertem ou depurem suas saídas anteriores. Em vez de tentar chegar no código perfeito desde o começo, os modelos podem trabalhar pra consertar o código com bugs que eles geraram, muitas vezes com informações adicionais, tipo mensagens de erro. Isso se parece mais com como o desenvolvimento de software real acontece, onde o código geralmente precisa de várias rodadas de refinamento. Cada rodada de refinamento precisa que o modelo seja chamado de novo, o que pode gerar resultados diferentes.

Como resultado, esse processo cria uma árvore de programas potenciais. Essa árvore pode ser infinitamente profunda porque qualquer programa refinado pode ser melhorado ainda mais e pode ser infinitamente larga devido às inúmeras possíveis melhorias que um LLM pode produzir. O sucesso desse método depende muito de como a estratégia de exploração e exploração é projetada. As estratégias existentes tiveram resultados mistos, especialmente quando os ganhos das melhorias foram marginais.

O equilíbrio entre exploração e exploração se torna mais complexo à medida que refinar um programa gera continuamente novos programas, criando mais ações possíveis. Abordagens tradicionais usadas pra problemas semelhantes não funcionam bem aqui por causa da natureza infinita de ramificação e os resultados aleatórios produzidos com cada refinamento.

Nossa principal contribuição é um novo Algoritmo pra refinar código com LLMs, que chamamos de REE. Essa abordagem pode ser vista como uma estratégia pra buscar através de uma árvore de refinamentos. A gente vê o problema como uma série de escolhas, onde escolher programas diferentes pra refinar pode levar a benefícios variados, dependendo da qualidade dos programas gerados.

Nesse esforço, a gente também apresenta uma visão geral dos problemas e como estruturamos nosso algoritmo pra melhorar a eficiência. O algoritmo tem aplicações amplas pra tarefas envolvendo geração de código. A gente explorou como nosso método se sai em desafios de programação competitiva, problemas que focam em verificação de software e quebra-cabeças que envolvem raciocínio visual.

#Informações de Fundo sobre Problemas de Bandit

Problemas de bandit envolvem maximizar recompensas a partir de um conjunto de ações, cada uma com um potencial desconhecido de sucesso. Em cada ponto de decisão, uma ação é escolhida e um feedback é recebido. O desafio tá em equilibrar a exploração-experimentando diferentes ações o suficiente pra aprender suas recompensas médias-em comparação com a exploração-selecionando a ação que se espera que traga a melhor recompensa.

Thompson Sampling é uma estrutura que ajuda a projetar estratégias pra esses tipos de problemas. Isso é feito tomando decisões com base na probabilidade de que cada opção seja a melhor. Ela acompanha crenças sobre as potenciais recompensas de cada ação e atualiza essas crenças com base em novas informações recebidas.

#Declaração do Problema e Suposições

Quando se trata de refinar programas, definimos nossa abordagem em torno de um problema de programação que vem com uma especificação que pode ser verificada de forma eficiente. Nosso objetivo é construir um programa que atenda às especificações necessárias.

As especificações geralmente se desmembram em restrições básicas, que podemos pensar como exemplos de entrada-saída. Ao avaliar um programa contra uma especificação, se ele não atender aos requisitos, podemos gerar facilmente contraexemplos pra ajudar a identificar as deficiências.

Refinar um programa significa solicitar a um LLM que o melhore com base em contraexemplos. Escrevemos sobre como nosso método organiza sua busca pra dar prioridade a programas que parecem estar a caminho de atender às especificações.

#O Algoritmo REE

A um nível alto, enquadramos a questão do refinamento como um problema de bandit de aquisição de braço. Cada programa representa uma opção, e refiná-lo envolve puxar o braço correspondente. As recompensas geradas estocasticamente nos informam se um programa gerado atende à especificação.

Nossa abordagem deriva do Thompson Sampling, onde estimamos quão provável é que um programa tenha sucesso com base em refinamentos anteriores. As recompensas são sucesso ou falha, o que significa que podemos usar um modelo simples de sucesso-falha pra guiar nossos refinamentos.

Assim, nosso algoritmo precisa acompanhar o valor heurístico de cada programa, quantas vezes ele foi refinado e selecionar o próximo programa pra refinar com base na maior recompensa potencial.

Essa abordagem nos permite estar um passo à frente usando as informações coletadas de tentativas anteriores, simplificando a complexidade que muitas vezes vemos em métodos tradicionais.

#Resultados Experimentais e Avaliação

Avaliamos nosso método em diferentes domínios, incluindo competições de programação, desafios de raciocínio visual e tarefas de verificação de software. Cada cenário apresentou desafios únicos e nosso objetivo foi determinar quão bem nosso método poderia resolver mais problemas enquanto minimizava o número de chamadas ao LLM.

Em competições de programação, comparamos com outros modelos e descobrimos que nossa abordagem muitas vezes superou eles. Tarefas de raciocínio visual exigiram a síntese de programas que podiam manipular imagens, enquanto tarefas de verificação de software envolveram gerar condições lógicas corretas.

#Velocidade e Eficiência de Custo

Uma vantagem do nosso método é que ele geralmente requer menos recursos computacionais do que alternativas. Ele também se sai melhor em tarefas mais difíceis, mostrando sua capacidade de não só resolver, mas de se destacar em situações complexas.

Importante ressaltar que nossos achados indicam que, embora nosso método possa não aumentar dramaticamente o número de problemas resolvidos à primeira vista, ele reduz significativamente o custo e o tempo total necessários pra chegar a soluções.

#Conclusão e Trabalho Futuro

Em conclusão, nossa exploração de como LLMs podem ser usados pra refinar código trouxe resultados promissores. O design do nosso algoritmo enfatiza eficiência e efetividade, garantindo que possamos enfrentar tanto problemas desafiadores quanto aqueles que requerem soluções rápidas.

Embora tenhamos aplicado principalmente esse algoritmo ao modelo GPT-4, seria interessante ver como outros modelos poderiam se beneficiar de técnicas semelhantes. A área de refinamento de código continua sendo um campo rico pra exploração, e acreditamos que, à medida que os modelos avançam, o potencial de melhorias nesse domínio só tende a crescer.

Pesquisas contínuas podem se concentrar em aprimorar as capacidades dos LLMs pra lidar melhor com as complexidades da síntese e refinamento de programas, levando, em última análise, a processos de desenvolvimento de software mais robustos.