💬 NLP

Function-Aware Fill-in-the-Middle as Mid-Training for Coding Agent Foundation Models

Este artigo introduz o preenchimento no meio (FIM) consciente de funções durante o treinamento intermediário, uma abordagem de auto-supervisão que aproveita a similaridade estrutural entre loops de agentes de codificação e chamadas de função para aumentar significativamente o desempenho de agentes de codificação em benchmarks como o SWE-Bench, enquanto simultaneamente preserva as capacidades gerais de codificação e uso de ferramentas que frequentemente são degradadas pelo pós-treinamento padrão.

Autores originais: Yubo Wang, Jiarong Liang, Yuxuan Zhang, Xuye Liu, Cong Wei, Yuyu Zhang, Ping Nie, Wenhu Chen

Publicado 2026-07-15

📖 5 min de leitura🧠 Leitura aprofundada

CC BY 4.0

Autores originais: Yubo Wang, Jiarong Liang, Yuxuan Zhang, Xuye Liu, Cong Wei, Yuyu Zhang, Ping Nie, Wenhu 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

Imagine que você está ensinando um robô a consertar bugs em uma biblioteca de código gigante e bagunçada. Normalmente, ensinamos esses robôs deixando-os ler livros do início ao fim, da esquerda para a direita. Mas há um problema: quando um robô realmente vai consertar um bug, ele não apenas lê para frente. Ele dá um passo, observa o que aconteceu (talvez uma ferramenta tenha gerado um erro) e então decide o que fazer a seguir. É um loop: Ação → Observação → Próximo Passo.

O loop do robô se parece exatamente com uma chamada de função em um código de computador normal.

A Ação do Robô é como uma função chamando outra função.
A Observação do Robô é como aquela função retornando um valor.
O Próximo Passo do Robô é como o resto do código usando esse valor.

A grande ideia? Em vez de apenas ler o código para frente, os autores ensinaram seus modelos de robô a jogar um jogo de "preencher a lacuna" com essas chamadas de função. Eles chamam isso de Function-Aware Fill-in-the-Middle (FIM) Mid-Training.

O Jogo: "Adivinhe a Peça Faltante"

Imagine que você tem uma história onde um personagem (o "chamador") pede a um amigo (o "chamado") para realizar uma tarefa, mas o trabalho real do amigo está oculto. O robô tem que adivinhar o que o amigo fez e explicar por que ele o fez, baseando-se apenas no contexto antes e depois.

Para tornar este jogo eficaz, os autores não apenas escolheram palavras aleatórias para esconder. Eles usaram um mapa especial do código (um "Grafo de Dependência de Programa") para encontrar os quebra-cabeças perfeitos. Eles procuraram por funções que fossem:

Complexas o suficiente para serem um bom desafio (não muito fáceis, nem impossíveis).
Previsíveis o suficiente para que o robô pudesse realmente entendê-las a partir das pistas ao redor.

Eles também fizeram o robô escrever uma "nota de raciocínio" (Chain-of-Thought) antes de escrever o código faltante, forçando-o a pensar antes de agir, exatamente como um programador humano faria.

Os Resultados: Isso Funciona?

Os autores testaram isso em três cérebros de robôs (modelos): dois da família Qwen2.5-Coder (7 bilhões e 14 bilhões de parâmetros) e um da nova família Qwen3 (8 bilhões de parâmetros). Eles treinaram esses robôs em um conjunto massivo de dados de 2,6 bilhões de tokens (palavras e símbolos) retirados de 968 repositórios de Python do mundo real.

Aqui está o que eles descobriram:

Melhor em Consertar Bugs: Quando testados em um benchmark famoso chamado SWE-Bench-Verified (que simula problemas de software do mundo real), os robôs melhoraram significamente.
- O modelo 7B melhorou +2,8%.
- O modelo 14B melhorou +3,0%.
- O modelo 8B melhorou +3,2%.
Ainda Melhor em Tarefas Mais Simples: Em uma versão mais leve do teste (SWE-Bench-Lite), os ganhos foram ainda maiores, com o modelo 8B saltando +5,4%.
Funciona em Todo Lugar: Essas melhorias aconteceram mesmo quando os robôs foram treinados usando métodos diferentes posteriormente. Isso sugere que o treinamento "fill-in-the-middle" deu a eles uma base sólida que permaneceu, não importa como fossem polidos depois.

A Surpresa: Não Quebrou Outras Habilidades

Normalmente, quando você treina um robô para ser um superespecialista (como um agente de correção de bugs), ele esquece como fazer outras coisas, como escrever código simples ou usar ferramentas. Os autores temiam que isso acontecesse.

Mas o "mid-training" na verdade salvou as outras habilidades dos robôs!

Sem este treinamento extra, os robôs pioravam na escrita de código por conta própria (caindo em benchmarks como o LiveCodeBench).
Com o treinamento FIM, eles não apenas permaneceram iguais, eles ficaram melhores (+11,1% no LiveCodeBench).
Embora os dados de treinamento fossem apenas código Python, os robôs melhoraram no uso de ferramentas em contextos completamente diferentes (como τ-bench e BFCL), sugerindo que aprenderam uma habilidade geral de "como pensar sobre causa e efeito" que se transferiu entre tarefas.

O Que Eles Explicitamente Descartaram

Os autores foram cuidadosos ao dizer o que este método não é:

Não é apenas copiar um professor inteligente: Eles testaram se o robô estava apenas memorizando as respostas de uma IA poderosa (Gemini-3-Flash) que ajudou a gerar os dados de treinamento. Eles descobriram que, mesmo quando o robô gerava suas próprias notas de raciocínio, ele ainda melhorava. Portanto, a magia não é apenas "copiar o professor"; é a estrutura do próprio jogo.
Não é uma solução mágica para tudo: O método funciona melhor quando o código é modular (dividido em funções organizadas). Se o código for um script gigante e bagunçado onde tudo está misturado, o método não funciona tão bem porque não consegue encontrar quebra-cabeças claros de "chamada de função" para resolver.
Não foi comprovado para todas as linguagens ainda: Os dados de treinamento foram apenas Python. Embora os robôs tenham melhorado em outras tarefas, os autores admitem que ainda não provaram que isso funciona para Java, C++ ou Rust.

O Quão Certos Eles Estão?

Os autores estão bastante confiantes em seus números porque realizaram os testes três vezes com diferentes sementes aleatórias para garantir que os resultados não fossem apenas sorte. Eles mediram as melhorias precisamente (ex: +2,8%, +3,0%) e mostraram que os robôs consistentemente resolviam mais problemas e cometiam menos erros quando ficavam travados.

Eles sugerem que este estágio de "mid-training" é um elo perdido crucial. É como dar ao robô um tipo específico de treino de academia antes de enviá-lo para o mundo real, garantindo que ele tenha os músculos certos para lidar com o loop complexo de "agir, observar e continuar" sem perder suas outras habilidades.

Resumo Técnico: Preenchimento de Lacunas Consciente de Funções como Mid-Training para Modelos de Fundação de Agentes de Codificação

Declaração do Problema

Agentes de codificação projetados para resolver problemas reais de engenharia de software dependem de uma estrutura de condicionamento específica: manter um histórico ( $h_t$ ), amostrar uma ação ( $a_t$ ), receber uma observação externa ( $o_{t+1}$ ) e continuar o raciocínio com base no traço completo. Embora o pré-treinamento padrão de código (previsão do próximo token da esquerda para a direita) exponha os modelos ao código, ele raramente otimiza para este loop específico de "ação $\to$ observação $\to$ continuação". Consequentemente, existe uma lacuna entre o pré-treinamento do modelo base e as demandas dos pipelines de pós-treinamento agênticos (ex: SWE-Gym, R2E-Gym).

Além disso, o objetivo padrão de Fill-in-the-Middle (FIM) usado no pré-treinamento de código está desalinhado com o raciocínio agêntico por três razões:

Fronteiras Arbitrárias: O mascaramento de spans aleatórios frequentemente corta expressões, falhando em capturar dependências de nível de função.
Falta de Raciocínio: O FIM padrão exige geração direta sem etapas intermediárias de raciocínio (Chain-of-Thought), ao contrário do padrão "pensar-então-agir" dos agentes.
Sinal Amortizado: Quando o FIM é dissolvido em um pré-treinamento massivo, o prior estrutural é diluído através de trilhões de tokens não relacionados antes que o pós-treinamento agêntico comece.

Metodologia

Os autores propõem o Function-Aware FIM Mid-Training, um estágio de auto-supervisão dedicado inserido entre o pré-treinamento e o pós-treinamento agêntico. Esta abordagem aproveita o isomorfismo estrutural entre o passo de um agente de codificação e um local de chamada de função em código comum:

Contexto/Histórico: Código pré-chamada estabelecendo a intenção.
Ação/Chamada: A própria chamada da função.
Observação/Retorno: O valor computado pelo callee (fora do escopo imediato).
Continuação: Código subsequente consumindo o valor de retorno.

Componentes Principais

Seleção de Alvo Consciente de Função:
Em vez de spans aleatórios, o método seleciona alvos de mascaramento na granularidade de função usando análise de Grafo de Dependência de Programa (PDG).
- Pontuação de Complexidade ( $\hat{H}$ ): Mede a dificuldade intrínseca baseada em Linhas de Código (LoC), Complexidade Ciclomática de McCabe e profundidade de aninhamento.
- Pontuação de Inferibilidade ( $\hat{I}$ ): Mede o quão recuperável uma função é a partir de seu contexto, agregando sinais de argumentos do chamador, dependências do callee, assinaturas de tipo, docstrings e irmãos de classe.
- Critério de Seleção: Os alvos são selecionados via uma combinação semelhante à média harmônica de $\hat{H}$ e $\hat{I}$ , penalizando alvos que sejam ou triviais demais ou impossíveis de aprender mesmo com contexto total.
Aumento de Chain-of-Thought (CoT):
Para os alvos selecionados, o modelo é treinado para gerar um racional passo a passo antes do corpo da função.
- Geração: Um modelo de fronteira (Gemini-3-Flash) gera o racional e um corpo candidato baseado apenas no contexto do arquivo mascarado (sem acesso ao ground truth).
- Filtragem: Um modelo juiz filtra os pares com base na viabilidade e qualidade.
- Formato de Treinamento: O prompt de treinamento segue <fim_prefix> ... <fim_suffix> ... <fim_middle> <racional> <body>. Isso força o modelo a aprender a estrutura "pensar-então-agir".
Curadoria de Dados:
O corpus consiste em 968 repositórios Python descontaminados do GitHub (2.6B tokens). Repositórios que sobrepõem fontes do SWE-Bench foram removidos, e os commits foram restringidos a datas anteriores aos commits base do SWE-Bench para evitar vazamento no tempo de teste.

Principais Contribuições

Analogia Estrutural: Enquadrar locais de chamada de função como o análogo em escala de internet do loop ação–observação–continuação do agente, motivando o FIM de granularidade de função como um prior auto-supervisionado.
Design de Pipeline: Um pipeline de mid-training combinando seleção baseada em PDG, um duplo critério de complexidade–inferibilidade e racionais de CoT incorporados.
Validação de Robustez: Demonstrar ganhos consistentes em diferentes tamanhos de modelo (Qwen2.5-Coder 7B/14B, Qwen3-8B), diferentes pipelines de pós-treinamento (R2E-Gym, SWE-Smith, SWE-Lego) e diferentes famílias de modelos base.
Transferência Cross-Domain: Mostrar que um corpus de mid-training apenas de Python melhora o desempenho em benchmarks de uso de ferramentas não-codificação ( $\tau$ -bench, BFCL) e preserva capacidades gerais de codificação (LiveCodeBench) que tipicamente se degradam durante o pós-treinamento agêntico.
Lançamento Aberto: Liberação do corpus descontaminado de 968 repositórios, do pipeline de seleção, dos checkpoints de mid-trained e do processo de seleção.

Resultados Experimentais

Desempenho Agêntico In-Domain

O método foi avaliado no SWE-Bench-Verified e SWE-Bench-Lite.

Qwen2.5-Coder-7B: Ganho de +2.8% no Verified, +3.7% no Lite (vs. apenas pós-treinamento).
Qwen2.5-Coder-14B: Ganho de +3.0% no Verified, +4.0% no Lite.
Qwen3-8B: Ganho de +3.2% no Verified, +5.4% no Lite.
Independência de Pipeline: Ganhos foram observados em R2E-Gym, SWE-Smith e SWE-Lego, indicando que o prior não é específico para uma única distribuição de dados.

Preservação de Capacidade e Transferência Cross-Domain

O pós-treinamento agêntico isolado foi encontrado como um degradador significativo de capacidades não-alvo (ex: LiveCodeBench caiu 13.1 pontos para o modelo 14B).

Restauração: Adicionar mid-training antes do pós-treinamento restaurou o desempenho do LiveCodeBench em +11.1 pontos, quase fechando a lacuna para o teto de instrução ajustada.
Uso de Ferramentas: Apesar do corpus conter apenas código Python e nenhum traço de uso de ferramenta, o mid-training melhorou o desempenho no $\tau$ -bench (+3.9) e BFCL (+2.4). Isso serve como evidência de que o viés indutivo de chamada de função se transfere para o raciocínio de uso de ferramentas geral.

Análise Comportamental

Análise de trajetórias agênticas revelou:

Recuperação de Erros: O agente mid-trained recuperou-se de observações negativas (ex: stack traces) a uma taxa de 28.8% comparado a 24.8% do baseline.
Iterar-e-Verificar: O modelo adotou uma política de mais edições e trajetórias mais longas (23.6 passos vs. 15.1), reduzindo falhas de "no-patch" em ordens de magnitude.
Granularidade: Ganhos foram mais pronunciados em tarefas que exigem raciocínio sobre dependências entre funções dentro de um único arquivo (+9.1 pontos em tarefas multi-função), confirmando a hipótesa de isomorfismo estrutural.

Significância e Alegações

O artigo afirma que o código fonte contém um "suprimento em escala de internet de sinal relevante para agentes" na forma de locais de chamada de função. Ao treinar explicitamente os modelos para raciocinar bidirecionalmente sobre essas dependências via FIM consciente de função, o método instala um prior estrutural que:

Melhora o Desempenho Agêntico: Aumenta diretamente as taxas de sucesso em benchmarks de engenharia de software.
Mitiga o Esquecimento Catastrófico: Previne a erosão de capacidades gerais de codificação e uso de ferramentas frequentemente causadas pelo pós-treinamento agêntico especializado.
Generaliza: Os benefícios transferem-se entre famílias de modelos e para tarefas de raciocínio de uso de ferramentas não-codificação, sugerindo que o viés indutivo aprendido é fundamental para o loop de raciocínio agêntico, e não específico para a geração de código Python.

Os autores observam limitações, incluindo a dependência de um corpus apenas de Python, dependência de um professor de fronteira (Gemini-3-Flash) para geração de CoT (embora o self-CoT recupere a maior parte dos ganhos) e a suposição de estruturas de código modulares.