Unseen-Codebases-Domain Data Synthesis and Training Based on Code Graphs

1. O Problema

Os Grandes Modelos de Linguagem (LLMs) demonstram desempenho excepcional em tarefas de engenharia de software quando treinados em ecossistemas de código públicos maduros (como GitHub). No entanto, eles sofrem significativamente ao lidar com codebases invisíveis (unseen codebases), que incluem:

• Bibliotecas recém-lançadas.
• Frameworks específicos de domínio.
• Sistemas corporativos proprietários.
• Componentes de terceiros privados.

Desafios Principais:

• Alucinação e Baixo Desempenho: Como esses modelos não foram expostos a esses ambientes durante o treinamento, eles frequentemente alucinam funcionalidades que não existem, usam componentes incorretamente ou falham em compilar.
• Limitações da Inferência (RAG): Técnicas de aumento em tempo de inferência, como Retrieval-Augmented Generation (RAG), ajudam a reduzir alucinações óbvias ao fornecer contexto, mas não resolvem o problema fundamental. O RAG não ensina ao modelo as relações intrínsecas, padrões de uso latentes e a composição correta de componentes que exigem um entendimento profundo da estrutura do repositório.
• Escassez de Dados de Treinamento: Diferente de domínios públicos, codebases invisíveis geralmente fornecem apenas o código-fonte de implementação. Não há exemplos de uso de alta qualidade, testes ou documentação que mostrem como os componentes devem ser combinados, tornando difícil a criação de dados de fine-tuning (SFT) tradicionais.

2. Metodologia: UCD-Training

Os autores propõem o UCD-Training (Unseen-Codebase-Domain Training), um framework de treinamento em duas etapas que injeta conhecimento específico do domínio diretamente no modelo, utilizando apenas o código-fonte disponível. O processo baseia-se na construção de um Grafo de Código para capturar as dependências e relações estruturais.

Etapa 1: Construção do Grafo de Código

O código-fonte é analisado para extrair entidades (arquivos, classes, funções, métodos, variáveis globais) como nós e suas relações (dependências, chamadas, inclusões) como arestas. Isso cria uma representação estruturada do repositório.

Etapa 2: Continual Pre-Training (CPT) Preservando Dependências

• Objetivo: Ensinar ao modelo a estrutura e as dependências do código.
• Técnica: O grafo de código é filtrado para extrair apenas nós de arquivos e suas dependências, formando um subgrafo acíclico direcionado.
• Algoritmo de Traversal: Em vez de uma ordenação topológica simples (que pode separar arquivos dependentes), o método utiliza uma travessia em profundidade (DFS) a partir de nós com grau de entrada zero.
• Construção de Dados: Os arquivos são concatenados seguindo o caminho da DFS. Uma estratégia de janela deslizante garante que arquivos com dependências diretas apareçam juntos na mesma sequência de treinamento. Isso força o modelo a aprender como os arquivos colaboram.

Etapa 3: Supervised Fine-Tuning (SFT) Baseado no Grafo

Nesta etapa, são sintetizados dados de treinamento orientados ao uso, enriquecidos com rastros de raciocínio explícitos (reasoning traces). Os dados são divididos em três categorias complementares:

1. Dados de Raciocínio de Relação de Um Salto (Single-hop): Derivados das arestas do grafo para capturar relações estruturais finas (ex: "A chama B"). Inclui exemplos positivos e negativos com rastros de raciocínio sobre por que uma relação existe ou não.
2. Dados de Raciocínio de API Compositiva: Gerados a partir de casos de teste internos do projeto. O sistema cria "questões de exame" que exigem a combinação de múltiplas APIs para resolver cenários funcionais. Isso simula o uso real e complexo do framework.
3. Dados de Utilização do Codebase: Transformação de casos de teste internos em tarefas de geração de funções. O modelo deve entender quais APIs invocar e como interagir com elas para passar nos testes.

Filtragem Rigorosa: Todos os dados sintetizados passam por um processo de filtragem em duas etapas (baseado em regras e LLM) para garantir consistência semântica e sintática, eliminando amostras de baixa qualidade ou alucinações.

3. Contribuições Chave

1. Framework UCD-Training: Uma abordagem inovadora que sintetiza dados de treinamento orientados ao raciocínio a partir de grafos de código, permitindo que LLMs aprendam codebases privados sem necessidade de dados de uso externos.
2. Novo Benchmark (UnseenCodeBench): Um conjunto de avaliação padronizado para codebases invisíveis, cobrindo C++ e Python, com projetos criados após a data de corte de conhecimento dos modelos avaliados (garantindo que são realmente "invisíveis").
3. Validação Empírica: Extensos experimentos demonstrando que a injeção de conhecimento via treinamento supera significativamente as abordagens de inferência (RAG) e outros métodos de síntese de dados.

4. Resultados Principais

Os experimentos foram conduzidos em múltiplos modelos (Qwen, DeepSeek, etc.) e tamanhos (8B a 32B parâmetros).

• Superioridade sobre RAG: O UCD-Training superou consistentemente as melhores abordagens baseadas em RAG. Por exemplo, com o modelo GPT-5.1, houve uma melhoria absoluta de 25,5% no pass@1 em comparação com o RAG.
• Desempenho Geral: No benchmark UnseenCodeBench, o método obteve ganhos de desempenho de 7,2% a 26,1% no Avg. pass@1 em comparação com métodos de síntese de dados existentes (como OSS-Instruct e COTTON).
• Escalabilidade: O método funcionou bem em diferentes tamanhos de modelo (8B, 14B, 32B) e linguagens (C++ e Python). Modelos de 8B treinados com UCD-Training superaram modelos de 14B treinados com métodos baselines em codebases complexos.
• Cenários Empresariais Reais: Em simulações onde um único modelo precisava adaptar-se a múltiplos codebases invisíveis e linguagens simultaneamente, o UCD-Training manteve a eficácia, alcançando 36,0% de pass@1 e superando todas as baselines em 4,7% a 23,6%.
• Estudo de Ablação: A análise mostrou que os dados de raciocínio de API composicional são o componente mais crítico; sua remoção causou uma queda drástica de até 29,7% no desempenho.

5. Significado e Impacto

O trabalho demonstra que a simples recuperação de código (RAG) é insuficiente para a adaptação a novos domínios de software. A injeção explícita de conhecimento estrutural e de uso através de treinamento (CPT e SFT) é essencial.

A principal inovação reside na capacidade de transformar código-fonte bruto em dados de treinamento ricos em raciocínio sem depender de documentação ou exemplos de uso externos. Isso oferece uma solução prática e escalável para empresas que desejam utilizar LLMs em seus sistemas proprietários e bibliotecas internas, onde os dados de treinamento tradicionais não existem. O método estabelece um novo padrão para a adaptação de modelos de IA a ecossistemas de software fechados e em rápida evolução.