Robustness and Reasoning Fidelity of Large Language Models in Long-Context Code Question Answering

1. O Problema

Os Grandes Modelos de Linguagem (LLMs) estão cada vez mais integrados em fluxos de trabalho de engenharia de software para tarefas que exigem raciocínio sobre contextos de código longos (milhares de linhas distribuídas em múltiplos arquivos). No entanto, a robustez desses modelos sob condições de entrada variáveis permanece incerta.

O problema central identificado é que as avaliações atuais (como o LongCodeBench original) focam principalmente na precisão em formatos fixos de múltipla escolha e em uma única linguagem (Python). Isso deixa lacunas críticas:

• Não se sabe se o raciocínio de longo contexto generaliza para linguagens legadas (como COBOL) e modernas (Java).
• O formato de múltipla escolha pode mascarar fraquezas, permitindo que os modelos explorem pistas superficiais (sobreposição léxica ou padrões posicionais) em vez de demonstrar compreensão genuína.
• Há uma falta de avaliação sistemática sobre a robustez a informações irrelevantes (ruído) e a variações na formulação da tarefa.

2. Metodologia

Os autores realizaram um estudo sistemático estendendo o LongCodeBench para avaliar a robustez e a fidelidade do raciocínio através de três dimensões principais:

A. Expansão de Conjuntos de Dados (Multilinguismo)

• Python: Mantiveram o dataset original do LongCodeBench.
• COBOL: Introduziram dois novos datasets derivados de sistemas empresariais reais:
  • OPPSCAL: Código-fonte público do Medicare Pricer (CMS), focado em algoritmos de precificação.
  • Internal IBM: Sistema corporativo interno para processamento de transações de alto volume.
• Java: Criaram um dataset a partir de quatro repositórios open-source populares no GitHub (Elasticsearch, Cassandra, Dubbo, Kafka), cobrindo desde compreensão de código até padrões de design.

B. Protocolos de Avaliação Controlada

Para ir além da precisão bruta, os autores aplicaram perturbações controladas:

1. Opções Embaralhadas (Shuffled): As opções de múltipla escolha são reordenadas aleatoriamente para testar a dependência de viéses posicionais.
2. Sem Opções (Open-Ended): As opções de resposta são removidas, forçando o modelo a gerar a resposta diretamente do contexto. Isso testa a lacuna entre "reconhecimento" (escolher) e "geração" (sintetizar).
3. Experimento "Agulha no Palheiro" (Needle-in-a-Haystack):
   • Agulha Relevante: Inserção de trechos de código necessários para a resposta em diferentes profundidades (Início, Meio, Fim) para medir viéses de primazia e recência.
   • Agulha Irrelevante: Inserção de código distrator para testar a robustez contra ruído.

C. Modelos Avaliados

O estudo testou diversos modelos de última geração (SOTA), incluindo GPT-4o, Gemini (2.5 Flash e Pro), Claude (4.5 Sonnet), Llama (3.1 e 3.3), Mistral, Qwen e Granite, em janelas de contexto de 32k a 1024k tokens.

3. Principais Contribuições

1. LongContextCodeQA: Uma extensão multilíngue do LongCodeBench com novos datasets de QA de longo contexto para COBOL e Java, permitindo a avaliação de generalização entre paradigmas de programação.
2. Suite de Avaliação de Robustez: Um conjunto de testes controlados (embaralhamento, geração aberta, injeção de distratores) projetado para expor falhas de raciocínio que avaliações padrão ignoram.
3. Estudo Empírico Abrangente: Uma análise detalhada que revela falhas consistentes nos modelos SOTA, incluindo a lacuna reconhecimento-geração, viéses posicionais e vulnerabilidade a informações irrelevantes.

4. Resultados Chave

A. Lacuna Reconhecimento vs. Geração

Houve uma queda drástica de desempenho quando as opções de múltipla escolha foram removidas:

• Python: A precisão caiu entre 15% e 35% pontos percentuais. Modelos como o Claude 4.5 Sonnet caíram de ~80% (com opções) para ~42% (sem opções).
• COBOL: A queda foi ainda mais severa (30-60 pontos). Modelos que atingiam >98% com opções caíram para ~32-60% sem elas. Isso indica que os modelos dependem fortemente de reconhecimento de padrões nas opções, não de reconstrução lógica.
• Java: A lacuna foi menor, mas ainda significativa, sugerindo que modelos modernos têm melhor capacidade de raciocínio livre em Java, mas ainda não são perfeitos.

B. Sensibilidade ao Contexto e Viés Posicional

• Viés de Recência: A maioria dos modelos demonstrou um forte viés de recência, performando melhor quando a informação relevante estava no final do contexto e pior no início ("Lost at the Start").
• Fragilidade em COBOL: O desempenho em COBOL degradou-se mais rapidamente em contextos longos e em posições iniciais comparado ao Java e Python, sugerindo que a "efetividade do contexto" é dependente da linguagem e menor para linguagens legadas com menos dados de treinamento.
• Distratores: A presença de código irrelevante (agulhas irrelevantes) causou degradação de desempenho, especialmente em contextos muito longos (128k+), onde o modelo falha em filtrar o ruído.

C. Desempenho por Modelo

• Gemini 2.5: Mostrou-se o mais robusto, especialmente nas configurações de geração aberta e em contextos longos de COBOL e Java.
• Llama e Mistral: Apresentaram grandes quedas de desempenho ao remover as opções, indicando forte dependência de reconhecimento.
• Qwen3-30B-Thinking: Demonstrou resiliência notável em COBOL, superando modelos maiores em cenários específicos de longo contexto.

5. Significado e Conclusão

O estudo conclui que, apesar das janelas de contexto de milhões de tokens, os LLMs atuais não são robustos para tarefas de raciocínio de código em escala real.

• Fragilidade: Os modelos são frágeis a perturbações que exigem raciocínio genuíno em vez de reconhecimento de padrões.
• Limitações de Avaliação: As métricas atuais de precisão em múltipla escolha superestimam drasticamente a capacidade real de compreensão e geração de código.
• Desafio para Manutenção de Software: A incapacidade de gerar respostas corretas sem opções pré-definidas e a sensibilidade a ruído representam riscos críticos para aplicações de manutenção de software legado (especialmente COBOL) e sistemas complexos.

O trabalho sugere que futuras pesquisas devem priorizar a mitigação da sensibilidade posicional e o aprimoramento do raciocínio composicional sobre grandes bases de código, em vez de apenas aumentar o tamanho da janela de contexto.