🤖 AI

LSem2Vec: A Simple yet Effective Two-Stage Approach for Source Code Embedding

Este artigo apresenta o LSem2Vec, um framework de dois estágios simples, porém eficaz, que combina modelos de linguagem de grande escala para extração semântica com modelos de embedding de sentenças para gerar representações de código-fonte robustas sem exigir treinamento ou ajuste fino custosos e específicos para tarefas, superando métodos não supervisionados existentes em múltiplos conjuntos de dados.

Autores originais: Zixiang Xian, Chenhui Cui, Rubing Huang, Chunrong Fang, Zhenyu Chen

Publicado 2026-08-19

📖 5 min de leitura🧠 Leitura aprofundada

CC BY 4.0

Autores originais: Zixiang Xian, Chenhui Cui, Rubing Huang, Chunrong Fang, Zhenyu Chen

Artigo original sob licença CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Esta é uma explicação gerada por IA do artigo abaixo. Não foi escrita nem endossada pelos autores. Para precisão técnica, consulte o artigo original. Ler aviso legal completo

No vasto cenário do software moderno, as linhas de código são os tijolos e a argamassa do nosso mundo digital. Assim como um planejador urbano precisa entender o traçado das ruas e dos edifícios para gerir uma metrópole, os engenheiros de software precisam entender a estrutura e o significado do código para manter, melhorar e proteger os sistemas que constroem. Um desafio crítico neste campo é reconhecer quando duas partes de código estão essencialmente fazendo a mesma coisa, mesmo que pareçam diferentes na superfície. Isso é conhecido como encontrar "clones", e ajuda os desenvolvedores a evitar redundâncias e a detectar riscos de segurança. Durante anos, os computadores lutaram com essa tarefa porque muitas vezes se perdem no volume colossal de texto ou falham em compreender a lógica subjacente quando a redação muda. Embora ferramentas poderosas de inteligência artificial tenham surgido recentemente, capazes de ler e escrever código, usá-las para comparar milhares de arquivos provou ser difícil, caro e propenso a erros, muitas vezes porque as ferramentas ficam sobrecarregadas pela extensão do código ou dão respostas incorretas quando solicitadas a fazer julgamentos complexos de uma só vez.

Uma equipe de pesquisadores introduziu agora um novo método chamado LSEM2VEC, que resolve esses problemas ao mudar a forma como o computador "lê" o código. Em vez de pedir a uma inteligência artificial massiva que encare dois arquivos longos e decida se são semelhantes — uma tarefa que frequentemente leva à confusão ou a erros — a nova abordagem divide o trabalho em dois passos simples e gerenciáveis. Primeiro, o sistema usa um modelo de linguagem de grande escala para atuar como um tradutor, lendo um trecho de código e escrevendo uma única frase clara que resume o que aquele código faz. Este passo remove os detalhes confusos e deixa apenas o significado central. Depois, uma segunda ferramenta especializada pega essa frase de resumo e a converte em um ponto matemático no espaço, conhecido como um embedding. Ao transformar o código nesses pontos, o computador pode facilmente medir a distância entre eles para ver o quão semelhantes são, sem nunca precisar reler os arquivos originais e extensos. Este processo é como ter um bibliotecário que primeiro escreve uma descrição de uma frase para cada livro em uma biblioteca enorme e depois agrupa os livros com base nessas descrições, em vez de tentar ler cada página de cada livro para encontrar correspondências.

Os pesquisadores testaram este método em três conjuntos diferentes de código escritos em várias linguagens de programação, incluindo C e Java, utilizando diversos modelos de inteligência artificial para garantir que os resultados fossem robustos. Eles compararam sua nova abordagem com muitos métodos existentes, incluindo aqueles que exigem treinamento extensivo em dados rotulados ou aqueles que tentam usar a inteligência artificial diretamente para a comparação. Os resultados foram impressionantes: o novo método superou consistentemente os outros, encontrando clones de código com uma precisão muito maior. Em um teste envolvendo código C, o sistema alcançou uma pontuação de precisão superior a 95 por cento, superando significativamente o segundo melhor método. Também se mostrou altamente eficaz ao agrupar códigos semelhantes, uma tarefa conhecida como agrupamento (clustering), na qual obteve uma pontuação de 0,99 no Índice Rand Ajustado, superando até mesmo métodos que foram treinados com supervisão humana, que alcançaram uma pontuação de 0,90.

Uma vantagem fundamental deste trabalho é que ele não exige o processo caro e demorado de treinar a inteligência artificial em conjuntos de dados específicos. Os métodos tradicionais muitas vezes precisam de milhares de exemplos de pares de código rotulados por humanos para aprender a identificar semelhanças, o que é lento e dispendioso. A nova abordagem funciona imediatamente, utilizando o conhecimento existente dos modelos de inteligência artificial sem qualquer treinamento adicional. Ela também resolve um obstáculo técnico importante: a memória limitada desses modelos. Modelos de linguagem de grande escala podem processar apenas uma certa quantidade de texto de cada vez; se o código for muito longo, o modelo trava ou desiste. Ao resumir o código primeiro, os pesquisadores contornaram esse limite, permitindo que o sistema lidasse com arquivos grandes que anteriormente seriam impossíveis de analisar. Além disso, o método é muito mais eficiente, exigindo muito menos chamadas aos modelos de inteligência artificial, o que economiza tempo e dinheiro.

O estudo também explorou como diferentes escolhas afetam o resultado, como o uso de diferentes tipos de modelos de inteligência artificial ou a remoção de "palavras de parada" (stop words) comuns dos resumos. Eles descobriram que, embora as ferramentas específicas importem, a abordagem geral permanece sólida em diferentes configurações. Por exemplo, usar um modelo de inteligência artificial mais avançado para escrever os resumos levou a melhores resultados, mas mesmo os modelos padrão desempenharam excepcionalmente bem. Os pesquisadores também visualizaram os resultados, mostrando que os pontos de código gerados pelo seu método formavam grupos coesos e claros, enquanto outros métodos produziam agrupamentos desordenados e sobrepostos. Essa clareza sugere que o sistema realmente compreende o significado do código, em vez de apenas corresponder a padrões superficiais.

Em última análise, esta pesquisa oferece uma maneira prática e eficiente de compreender os vastos oceanos de código que alimentam o nosso mundo. Ao simplificar a complexa tarefa de comparação de código em um processo de dois passos de sumarização e medição, os pesquisadores criaram uma ferramenta que é ao mesmo tempo poderosa e acessível. Demonstra que nem sempre precisamos construir modelos maiores e mais complexos para resolver problemas difíceis; às vezes, uma maneira mais inteligente de usar as ferramentas que já possuímos é suficiente para enxergar a floresta através das árvores. Esta abordagem pode ajudar engenheiros de software a limpar suas bases de código, encontrar vulnerabilidades de segurança ocultas e organizar seus projetos de forma mais eficaz, tudo isso sem o pesado custo computacional que anteriormente limitava essas capacidades.

Resumo Técnico de LSEM2VEC: Uma Abordagem de Embedding Eficaz para Detecção e Agrupamento de Clones de Código

Definição do Problema
A integração de Grandes Modelos de Linguagem (LLMs) na engenharia de software (SE) avançou tarefas como detecção e agrupamento de clones de código fonte. No entanto, os métodos existentes para gerar embeddings de código fonte enfrentam limitações significativas. Os modelos pré-treinados (PTMs) tradicionais frequentemente exigem treinamento supervisionado extensivo ou ajuste fino (fine-tuning) em dados específicos da tarefa, demandando recursos computacionais substanciais e conjuntos de dados rotulados. Embora os LLMs possuam capacidades impressionantes de aprendizado zero-shot, a aplicação direta deles em tarefas de SE apresenta dois desafios críticos:

Respostas Errôneas: Os LLMs frequentemente produzem saídas incorretas quando incumbidos de raciocínios complexos, como determinar se dois trechos de código são clones, especialmente quando o fluxo de trabalho envolve resumir a funcionalidade e, em seguida, tomar uma decisão binária.
Limitações de Comprimento de Contexto: Os LLMs possuem janelas de contexto fixas. Processar grandes volumes de código fonte ou comparar múltiplos pares de código simultaneamente frequentemente excede esses limites, levando a erros ou à incapacidade de processar fragmentos de código longos. Além disso, a comparação direta par a par usando LLMs resulta em complexidade de tempo quadrática ( $O(n^2)$ ) em relação às chamadas de LLM, tornando-a ineficiente e dispendiosa para grandes conjuntos de dados.

Metodologia: LSEM2VEC
Os autores propõem o LSEM2VEC (LLM-extracted code Semantics to Vector embedding), uma abordagem inovadora e livre de treinamento que gera embeddings de código fonte combinando LLMs com modelos de embedding de sentenças. O framework opera através de um pipeline de quatro estágios projetado para mitigar os desafios mencionados por meio de uma estratégia de "interação tardia" (late-interaction):

Design de Prompt Uniforme: Um template de prompt padronizado instrui o LLM a ler um fragmento de código fonte e resumir sucintamente sua função em uma única frase, proibindo explicitamente textos explicativos. Isso garante a compatibilidade com modelos de embedding de sentença, que esperam entradas de frase única.
Resumos de Código e Armazenamento: O LLM gera o resumo de uma frase para cada fragmento de código. Crucialmente, o sistema extrai apenas a primeira frase da resposta para garantir a consistência e armazena esses resumos em formato JSON. Esta etapa desacopla a extração semântica da tarefa subsequente, permitindo que os resumos sejam reutilizados sem novas consultas ao LLM.
Geração de Embedding de Código: Os resumos de texto armazenados são alimentados em um modelo de embedding de sentença pré-treinado (ex: MiniLM ou SBERT-CN) para gerar representações vetoriais de dimensão fixa. Esta etapa converte os resumos de linguagem natural em vetores semânticos sem qualquer treinamento ou ajuste fino adicional.
Tarefas Subsequentes: Os embeddings resultantes são usados para tarefas não supervisionadas. Para detecção de clone de código, a similaridade é calculada usando a similaridade de cosseno entre pares de vetores. Para agrupamento de código (clustering), a distância euclidiana é usada com o algoritmo K-means.

Este design de "interação tardia" reduz a complexidade computacional da detecção de clone de código de $O(n^2)$ (exigindo uma chamada de LLM para cada par de código) para $O(n)$ (exigindo apenas uma chamada de LLM por fragmento de código), reduzindo significativamente os custos de tokens e evitando o transbordamento do comprimento do contexto.

Principais Contribuições
O artigo reivindica as seguintes contribções:

Primeira Integração Livre de Treinamento: É o primeiro trabalho a empregar modelos de linguagem de grande escala e de embedding de sentença para gerar embeddings de código fonte sem exigir qualquer treinamento ou ajuste fino, utilizando conjuntos de dados não rotulados.
Mitigação das Limitações de LLM: O pipeline proposto aborda efetivamente as respostas errôneas de LLM e as restrições de comprimento de contexto ao dividir a tarefa em etapas menores (sumarização seguida de embedding) em vez de pedir ao LLM para realizar toda a tarefa de raciocínio diretamente.
Flexibilidade e Escalabilidade: A abordagem é independente de LLM, permitindo o uso de qualquer LLM de código aberto ou proprietário e vários modelos de embedding de sentença. Ela escala através de diferentes linguagens de programação sem necessidade de dados de treinamento específicos da linguagem.
Eficiência: Ao reduzir o número de chamadas de LLM e aproveitar codificadores de sentença pré-treinados, o método oferece uma solução de recursos eficientes em comparação com modelos ajustados ou prompting direto de LLM.

Resultados Experimentais
Os autores avaliaram o LSEM2VEC em três conjuntos de dados (POJ-104, OJClone C e BigCloneBench) cobrindo as linguagens C e Java. A avaliação focou em detecção de clone de código não supervisionada e agrupamento de código usando GPT-3.5, GLM3 e GLM4.

Detecção de Clone de Código: O LSEM2VEC superou significativamente os métodos não supervisionados de estado da arte, incluindo SourcererCC, Code2vec, InferCode, TransformCode e LLM2Vec.
- No conjunto de dados OJClone C, a melhor configuração (GPT-3.5 + MiniLM-L12) alcançou um F1-score de 91,82%, superando o LLM2Vec supervisionado (83,70%) e outros baselines não supervisionados.
- No conjunto de dados BigCloneBench, o LSEM2VEC alcançou F1-scores de até 85,83% (usando GPT-3.5 + MiniLM-L6), novamente superando o LLM2Vec supervisionado e outros métodos.
- O estudo descobriu que o GPT-3.5 geralmente rendeu melhores resultados do que os modelos da série GLM (GLM3 e GLM4), e que a escolha do modelo de embedding de sentença (ex: MiniLM-L12 vs. L6) impactou o desempenho.
Agrupamento de Código (Clustering): Usando o Índice Rand Ajustado (ARI) como métrica, o LSEM2VEC demonstrou capacidades de agrupamento superiores.
- A configuração GPT-3.5 alcançou um ARI de 0,97 (usando MiniLM-L6) e 0,91 (usando MiniLM-L12), superando o LLM2Vec supervisionado (0,90) e todos os outros baselines não supervisionados.
- A visualização via t-SNE confirmou que os embeddings do LSEM2VEC produziram fronteiras de clusters bem definidas e distintas, particularmente ao usar LLMs mais avançados como o GPT-3.5 em comparação ao GLM3.

Significância e Alegações
O artigo posiciona o LSEM2VEC como uma alternativa robusta e eficiente às estratégias de embedding existentes. Sua principal significância reside em demonstrar que embeddings de código fonte de alta qualidade podem ser gerados sem o custo computacional do ajuste fino ou a dependência de dados rotulados. Ao alavancar as capacidades zero-shot de LLMs para extração semântica e modelos de sentença para vetorização, a abordagem fornece uma solução prática para aplicações reais de SE onde os recursos são limitados. Os autores concluem que este método oferece um novo direcionamento para a comunidade explorar representações avançadas de código fonte, potencialmente estendendo-se para tarefas como sumarização de código, detecção de vulnerabilidades e análise de código binário em trabalhos futuros.

Mais como este