Precision or Peril: A PoC of Python Code Quality from Quantized Large Language Models

1. Problema e Contexto

Os Grandes Modelos de Linguagem (LLMs) demonstraram capacidades avançadas na geração de código, automatizando tarefas como conclusão e análise. No entanto, modelos de ponta (como GPT-5 ou LLaMA-405B) exigem recursos computacionais massivos e energia, limitando sua adoção por organizações menores. A quantização (redução da precisão dos pesos do modelo, ex: 8-bit ou 4-bit) é uma técnica comum para reduzir a pegada de memória e os requisitos de hardware.

O problema central investigado é a comprometida qualidade do código gerado por LLMs menores e quantizados. Embora a quantização permita a execução em hardware limitado, ela pode introduzir "perda de qualidade", resultando em código incompleto, ineficiente ou com erros lógicos. A literatura existente ainda explora pouco a interação entre a compressão de modelos e a qualidade do software gerado, bem como a correlação entre métricas de benchmark, similaridade de código e análise estática.

2. Metodologia

O estudo adotou uma abordagem sistemática para avaliar quatro LLMs de código aberto (com menos de 10 bilhões de parâmetros) em três dimensões: desempenho em benchmarks, métricas de similaridade e análise estática.

• Modelos Selecionados: WizardCoder 7B, Mistral Instruct 7B, StarCoder 2 7B e LlamaCode 7B.
• Configurações de Quantização: Cada modelo foi testado em três estados: não quantizado (base), quantizado em 8-bit e quantizado em 4-bit (utilizando o método AWQ - Activation Aware Weight Quantization).
• Benchmarks:
  • HumanEvalPlus: 164 problemas de Python de dificuldade média.
  • MBPP Plus: ~800 problemas de Python de dificuldade fácil.
• Pipeline Experimental:
  1. Geração de uma solução de código por prompt (sem engenharia de prompt).
  2. Execução de testes unitários para calcular a taxa de aprovação (pass@1).
  3. Cálculo da similaridade com soluções humanas usando CodeBLEU.
  4. Conversão das soluções em arquivos Python para análise estática com SonarQube (focando em cheiros de código, segurança, confiabilidade e manutenibilidade).
• Ambiente: GPU Nvidia RTX 3090 (24GB VRAM), Ubuntu 22.04, PyTorch 2.

3. Principais Contribuições

• Avaliação Multidimensional: Integração de benchmarks funcionais, métricas de similaridade (CodeBLEU) e análise estática de qualidade (SonarQube) para uma visão holística.
• Impacto da Quantização: Análise comparativa detalhada de como a quantização (4-bit e 8-bit) afeta não apenas a funcionalidade, mas também a estrutura e a manutenibilidade do código gerado.
• Identificação de Padrões de Falha: Detecção sistemática de "cheiros de código" (code smells) e problemas de qualidade específicos em LLMs menores.
• Repositório Público: Disponibilização de todos os dados e códigos de análise para reprodutibilidade.

4. Resultados Chave

A. Desempenho em Benchmarks (RQ1)

• Desempenho Geral Baixo: Todos os modelos de 7B parâmetros apresentaram desempenho limitado. O melhor modelo, Mistral Instruct 7B, atingiu apenas 34,1% de taxa de aprovação no MBPP Plus e 27,6% no HumanEvalPlus. O StarCoder 2 7B teve o pior desempenho (< 2%).
• Discrepância CodeBLEU vs. Funcionalidade: Os modelos obtiveram pontuações de CodeBLEU mais altas (0,20–0,30) do que suas taxas de aprovação de testes unitários. Isso sugere que os LLMs priorizam a similaridade sintática e de padrões em relação à funcionalidade real e casos de borda. O CodeBLEU não é um substituto confiável para testes unitários.

B. Efeito da Quantização (RQ2)

• Impacto Variável: A quantização teve efeitos mistos.
  • Mistral e WizardCoder: Sofreram degradação significativa na funcionalidade ao serem quantizados (perdas de até 13% no HumanEvalPlus para o Mistral).
  • CodeLlama e StarCoder: Foram menos afetados pela quantização.
• Estrutura vs. Lógica: A quantização teve pouco impacto na estrutura e sintaxe do código (mantendo pontuações de CodeBLEU estáveis), mas afetou fortemente a lógica e a correção funcional.
• Recomendação: É necessário testar modelos em diferentes configurações de quantização antes de usá-los em produção.

C. Qualidade do Código e Análise Estática (RQ3)

• Volume de Problemas: Das 6.756 soluções geradas, foram detectadas 1.848 questões pelo SonarQube, com um custo estimado de 33 dias de esforço de desenvolvimento para correção.
• Tipos de Problemas:
  • 85,2% das questões foram de Manutenibilidade (cheiros de código, estilo, estrutura).
  • Apenas 3 questões foram de Segurança e 282 de Confiabilidade.
  • A maioria dos problemas (59,6%) estava relacionada à Intencionalidade (clareza e lógica), seguida por Consistência (31,2%).
• Violações Comuns: Nomes de funções inconsistentes, variáveis não utilizadas, comentários de código comentados, testes de igualdade com floats e complexidade cognitiva excessiva.
• Análise Manual: Revelou problemas recorrentes como definições de funções repetidas, loops infinitos de impressão, lógica incompleta (placeholders # TODO) e inclusão de conteúdo Markdown em vez de código executável.

D. Quantização vs. Qualidade (Contraintuitivo)

• Surpreendentemente, os modelos quantizados em 4-bit geraram o maior número de problemas (770), seguidos pelos não quantizados (571) e, finalmente, os quantizados em 8-bit (507).
• Isso indica que a quantização em 8-bit pode, em alguns casos, equilibrar a compressão e a qualidade, enquanto a quantização em 4-bit degrada significativamente a precisão lógica.

5. Significado e Conclusão

O estudo conclui que, embora LLMs menores e quantizados possam gerar código funcional, eles não atendem aos padrões profissionais de clareza e manutenibilidade sem validação rigorosa.

• Riscos: A integração direta de código gerado por esses modelos em projetos de software introduz dívida técnica significativa, problemas de legibilidade e riscos de manutenção, mesmo que o código passe nos testes unitários básicos.
• Implicações Práticas: Desenvolvedores não devem confiar apenas em métricas de similaridade (como CodeBLEU) ou na capacidade de "passar testes". É essencial utilizar análise estática (SonarQube) e revisão humana.
• Futuro: A pesquisa sugere que a engenharia de prompts, técnicas de auto-reparo e a geração de múltiplas amostras são necessárias para melhorar a qualidade. Além disso, a escolha da granularidade de quantização (8-bit vs 4-bit) deve ser feita com base no trade-off entre recursos e qualidade do código, e não apenas na economia de memória.

Em suma, o uso de LLMs quantizados para geração de código é uma "Precisão ou Perigo": oferece acessibilidade computacional, mas exige cautela extrema quanto à qualidade e robustez do software resultante.