Resumo Técnico: Colapso de Autotreinamento Recursivo em Code LLMs

1. Definição do Problema

O artigo investiga o risco de colapso de autotreinamento recursivo em Large Language Models (LLMs) de código. À medida que as ferramentas de IA para codificação (ex: GitHub Copilot, Cursor) geram cada vez mais código que é mesclado em repositórios públicos, os corpora de treinamento futuros poderão consistir majoritariamente de código gerado por IA. Se um modelo for ajustado (fine-tuned) em dados que ele mesmo gerou anteriormente, e esses dados forem subsequentemente usados para treinar a próxima iteração sem controle de qualidade externo, o sistema entra em um ciclo de "autoconsumo".

O problema central é que, sem dados humanos novos ou sinais de qualidade exógenos, este ciclo pode levar ao colapso do modelo:

• Deriva Distribucional: O modelo aprende a imitar seus próprios outputs anteriores em vez da distribuição original dos dados.
• Amplificação de Erros: Bugs, lógica incompleta e estreitamento estilístico no código gerado são copiados e reforçados nas gerações subsequentes.
• Perda de Diversidade: O modelo converge para outputs de baixa variância e baixa qualidade, falhando em resolver tarefas de programação de forma eficaz.

O artigo contrasta especificamente três regimes de treinamento recursivo:

1. Sem Revisão (Não-controlado): Todo o código gerado é reutilizado.
2. Revisão com Gate Humano: O código é filtrado por sinais independentes do modelo (ex: compilação, análise estática, testes de execução).
3. Revisão com Gate de IA (Auto-gate): O LLM de código avalia e filtra seus próprios outputs usando sinais internos (ex: perplexidade, auto-pontuação binária).

2. Metodologia

Estrutura Teórica

Os autores formalizam o treinamento recursivo como reponderação de distribuição com gate (gated distributional reweighting).

• Recursão Não-controlada: A distribuição de treinamento na iteração $t$ é simplesmente a distribuição de saída do modelo $p_{\theta_t}(c|x)$. O próximo modelo minimiza a divergência KL em relação a esta distribuição, impondo apenas autoconsistência.
• Recursão com Gate: Uma amostra é aceita com probabilidade $r(x, c)$. A distribuição de treinamento torna-se $q_{\theta_t}(c|x) \propto p_{\theta_t}(c|x)r(x, c)$.
• Análise Teórica:
  • Concentração Espectral: Os autores provam (Proposição 2.1) que o retreinamento recursivo amplifica direções de representação dominantes enquanto suprime outras, levando a um colapso na matriz de covariância do espaço de representação (redução de rank/diversidade).
  • Degeneração do Auto-gate de IA: O artigo prova (Teorema 2.3) que, se um revisor de IA estiver acoplado ao gerador (compartilhando parâmetros ou distribuição), e o revisor tornar-se "autoconfirmador" (atribuindo pontuações altas aos outputs prováveis do gerador, independentemente da qualidade), o mecanismo de gate degenera matematicamente para o autotreinamento não-controlado. Neste regime de "carimbo de aprovação" (rubber-stamp), o filtro perde sua capacidade de rejeitar outputs degradados.
  • Condição de Estabilidade: O treinamento com gate de IA só evita o colapso se o revisor de IA permanecer calibrado a um padrão humano exógeno (Teorema 2.6).

Configuração Experimental

• Modelos: Quatro famílias de Code LLMs foram testadas: SantaCoder (1.1B), StarCoder2-3B, Qwen2.5-Coder-1.5B e Code Llama-7B.
• Benchmarks: HumanEval, MBPP, LiveCodeBench e suas versões aumentadas (HumanEval+, MBPP+).
• Protocolo: Fine-tuning recursivo ao longo de 5 rodadas. Em cada rodada, o modelo gera código, uma estratégia de filtragem seleciona 5.000 amostras e o modelo é ajustado sobre este conjunto por 3.000 passos.
• Estratégias de Filtragem:
  • Vanilla: Sem filtro.
  • Gates Humanos: Compile (verificação de sintaxe), Quality (métricas estáticas como repetição/comprimento), Compile+Quality.
  • Auto-gates de IA: Perplexity (os 25% de menor likelihood pelo modelo), Binary Classifier (os 25% superiores por score de diferença de logits).

3. Principais Resultados

Degradação Universal

Em todas as famílias de modelos e estratégias de filtragem, o autotreinamento recursivo leva à degradação de desempenho em comparação com o baseline de pré-treinamento.

• Sem Revisão: Colapsa de forma mais rápida e severa. Por exemplo, o Qwen2.5-Coder caiu de um baseline de HumanEval+ de 0.372 para 0.043 (−88.4%) na Rodada 5.
• Gates Humanos: Retardam a taxa de colapso, mas não o interrompem. Embora os filtros Compile e Quality preservem a validade executável e retardem a deriva semântica, eles não conseguem prevenir a degradação de longo horizonte.
• Auto-gates de IA: Exibem um modo de falha de "carimbo de aprovação". Inicialmente, podem selecionar amostras de alto desempenho (ex: o Binary Classifier alcançou o maior HumanEval+ na Rodada 5 para três modelos), mas sua eficácia de filtragem degrada-se com o tempo.
  • Divergência de Métricas: Uma descoberta crítica é a divergência entre o sinal interno do filtro e a correção real. Para o Binary Classifier, os scores de aceitação (a confiança do modelo em seu próprio código) subiram enquanto a correção nos benchmarks caiu. Isso confirma a previsão teórica de que o auto-gate torna-se autoconfirmador.

Consistência entre Modelos

O fenômeno do colapso não é específico de uma única arquitetura.

• LiveCodeBench: Todos os modelos aproximaram-se de um pass@1 próximo de zero neste benchmark fora de distribuição até a Rodada 5 sob treinamento vanilla, indicando que o autotreinamento recursivo degrada desproporcionalmente as capacidades de raciocínio complexo.
• Magnitude do Colapso: Modelos com distribuições iniciais mais fortes (ex: Qwen2.5-Coder) mostraram mudanças distributivas mais agudas quando contaminados com outputs autogerados, embora todos os modelos eventualmente convergiram para um "atrator de colapso" de baixo desempenho.

Taxas de Passagem de Filtros

• Gates Humanos: Mantiveram taxas de passagem estáveis (ex: Compile permaneceu alto porque depende de execução externa).
• Auto-gates de IA: Mostraram taxas de passagem crescentes ao longo das rodadas (ex: a taxa de passagem de Perplexity subiu de ~0.17 para ~0.24), indicando uma perda de poder discriminativo conforme a distribuição de scoring interno do modelo derivava junto com sua distribuição de geração degradada.

4. Contribuições

1. Estudo Empírico do Colapso de Code LLM: Forneceu uma avaliação sistemática do autotreinamento recursivo através de cinco regimes de filtragem e quatro distintas famílias de Code LLM, demonstrando que o colapso é um fenômeno transversal a modelos.
2. Formulação de Revisão como Redimensionamento de Amostragem com Gate: Enquadrou teoricamente a revisão de código como um mecanismo de reponderação de amostragem, explicando por que gates exógenos retardam o colapso enquanto gates endógenos falham.
3. Identificação da Exogeneidade como Chave: Estabeleceu que a diferença crítica entre treinamento recursivo bem-sucedido e falho é se a regra de aceitação é exógena (fixa, independente do modelo) ou endógena (acoplada ao gerador).
4. Prova Teórica de Degeneração: Provou que o auto-gate de IA degenera para o autotreinamento não-controlado sob condições de autoconfirmação e forneceu uma análise espectral mostrando como o retreinamento recursivo concentra a variância de representação em um subespaço de baixa dimensão.

5. Significância e Alegações

O artigo argumenta que o treinamento estável de código recursivo para LLMs requer verificação exógena em vez de auto-revisão acoplada ao modelo.

• Limitação da Revisão por IA: O estudo sugere que confiar em sistemas de IA para revisar seu próprio código para treinamentos futuros é inerentemente instável. À medida que o gerador degrada, os critérios do revisor também derivam, eventualmente aceitando outputs degradados como de alta qualidade (o regime de "carimbo de aprovação").
• Papel dos Gates Humanos: Embora os gates humanos (compilação, análise estática) sejam mais robustos e preservem a validade executável, eles são insuficientes para deter inteiramente a deriva semântica de longo horizonte. Eles atuam como um freio, não como uma cura.
• Implicação para Sistemas Futuros: As descobertas alertam contra o loop de "autoconsumo", onde o código gerado por IA entra nos repositórios e é imediatamente usado para treinar a próxima geração de modelos sem dados humanos novos ou sinais externos fortes. O artigo conclui que, para evitar o colapso, o sinal de verificação deve permanecer fora da distribuição de preferência do próprio modelo.

Os autores mantêm a modéstia, observando que seus experimentos focaram em Python e modelos de até 7B parâmetros, e que horizontes mais longos, modelos maiores e gates baseados em execução mais fortes permanecem como áreas abertas para investigações futuras.