Benchmarking Requirement-to-Architecture Generation with Hybrid Evaluation

Título: Benchmarking de Geração de Arquitetura a partir de Requisitos com Avaliação Híbrida

1. Problema e Motivação

A geração automática de designs de arquitetura de software a partir de documentos de requisitos (PRDs - Product Requirements Documents) é um passo crucial no desenvolvimento de software, mas enfrenta desafios significativos:

• Falta de Dados: Não existem conjuntos de dados funcionais e padronizados que liguem PRDs do mundo real a diagramas de arquitetura de referência.
• Limitações das Abordagens Atuais: Métodos tradicionais dependem de arquitetos humanos, o que é lento e propenso a erros. Soluções baseadas em LLMs (Modelos de Linguagem de Grande Porte) emergentes ainda carecem de benchmarks robustos.
• Deficiências na Avaliação: Métricas tradicionais de geração de texto (como BLEU e ROUGE) falham em capturar a validade estrutural de diagramas. Abordagens que usam apenas "LLM como Juiz" (LLM-as-a-Judge) são suscetíveis a viés e alucinações, sendo insuficientes para avaliar topologias complexas.
• Desafio Específico: LLMs tendem a gerar componentes corretos, mas falham em inferir as relações e dependências entre eles, resultando em arquiteturas fragmentadas.

2. Metodologia: R2ABench

Os autores introduzem o R2ABench (Requirement-To-Architecture Benchmark), um novo benchmark e pipeline de avaliação composto por três fases principais:

A. Construção do Dataset

• Origem: 17 projetos de software reais (9 em Python, 8 em Java) de um curso de mestrado, cobrindo diversos domínios (IA, Engenharia de Software, AIGC, etc.).
• Entrada: Documentos de Requisitos (PRDs) estruturados em seis seções: Introdução, Objetivos Principais, Funcionalidades, Restrições Técnicas, Requisitos Não Funcionais e Descrição da Arquitetura.
• Saída de Referência (Ground Truth): Diagramas de arquitetura convertidos manualmente para código PlantUML e validados por especialistas com 5+ anos de experiência, garantindo precisão nas hierarquias e relações.

B. Graduação de Contexto (Ablação)
Para testar a capacidade de raciocínio dos modelos, os autores criaram três cenários de entrada:

1. Full (Completo): Todo o PRD (seis seções).
2. -Arch (Sem Arquitetura): Remove a seção de "Descrição da Arquitetura", forçando o modelo a inferir a estrutura apenas a partir de requisitos funcionais e não funcionais.
3. Min (Mínimo): Mantém apenas "Objetivos Principais" e "Funcionalidades", testando o conhecimento prévio do modelo e o risco de generalização excessiva.

C. Framework de Avaliação Híbrida (Três Camadas)
O framework avalia os diagramas gerados ($G_p$) contra a referência ($G_t$) em três dimensões complementares:

1. Métricas de Grafos Estruturais:
   • Validade Sintática (SV): Capacidade de compilar o código PlantUML.
   • Precisão Semântica: F1-Score para nós (componentes) e arestas (relações), além de precisão de camadas.
   • Distância de Edição de Grafos (GED): Medida de similaridade topológica global.
2. Avaliação Multidimensional (LLM-as-a-Judge + Pontuação Humana):
   • Avalia completude, precisão (ausência de alucinações), racionalidade (princípios de engenharia) e legibilidade estrutural.
3. Detecção de Anti-padrões Arquiteturais:
   • Taxa de Componentes Órfãos ($R_{orphan}$): Componentes isolados sem conexões.
   • Taxa de Componentes "Deus" ($R_{god}$): Nós com conexões excessivas (centralização de responsabilidade).

3. Principais Contribuições

1. R2ABench: O primeiro benchmark focado na geração de diagramas de arquitetura a partir de PRDs não estruturados do mundo real, com dados validados por especialistas.
2. Framework de Avaliação Híbrido: Uma metodologia robusta que combina métricas gráficas rigorosas, avaliação semântica por LLM e detecção de anti-padrões de engenharia de software.
3. Estudo Empírico Abrangente: Avaliação de modelos SOTA (GPT-5, Claude, Gemini, DeepSeek, Qwen) e frameworks de agentes (MetaGPT, OpenHands), incluindo análises de ablação e padrões de erro.

4. Resultados Chave

• Desempenho Geral: Os modelos demonstram alta validade sintática e robustez na extração de entidades (nós), mas falham fundamentalmente no raciocínio relacional (arestas).
  • F1 de Nós: ~0.55 (Moderado).
  • F1 de Arestas: < 0.20 (Muito baixo), indicando dificuldade em mapear fluxos de dados e dependências.
• Modelos Especializados em Código: Modelos como o Qwen3-coder superaram modelos gerais (como GPT-5 e Gemini) na geração de relações, sugerindo que o treinamento focado em código ajuda a capturar dependências estruturadas.
• Impacto dos Agentes: A integração de frameworks de agentes (MetaGPT, OpenHands) não trouxe melhorias consistentes. Em muitos casos, causou instabilidade, degradação na taxa de compilação e piora nas métricas de precisão, sugerindo que a sobrecarga de processos de agente perturba a geração nativa do modelo.
• Efeito da Esparsidade de Informação (Ablação):
  • A remoção de detalhes arquiteturais teve impacto mínimo na extração de entidades (os modelos mantiveram a capacidade de identificar componentes).
  • No entanto, causou fragmentação severa da topologia: sem restrições explícitas, os modelos não conseguem deduzir fluxos de dados, deixando componentes isolados e aumentando alucinações para preencher lacunas.
• Padrões de Erro:
  • Omissão (E1): Agregação excessiva de sub-nós internos.
  • Alucinação (E2): Injeção de componentes não solicitados (ex: adicionar "Log Aggregator" ou bancos de dados específicos baseados em vieses de treinamento).
  • Falha Relacional (E4): Incapacidade de inferir interações dinâmicas, resultando em redes desconectadas ou planos.

5. Significância e Conclusão

O trabalho estabelece uma base padronizada e rigorosa para o avanço da geração de arquitetura de software assistida por IA.

• Insight Principal: LLMs atuais são bons em "o que" construir (componentes), mas ruins em "como" conectá-los (arquitetura e dependências).
• Implicação Prática: O uso de agentes complexos para esta tarefa específica ainda não é maduro e pode ser contraproducente. Modelos especializados em código mostram mais promessa.
• Futuro: O R2ABench serve como um ponto de partida para desenvolver modelos capazes de realizar raciocínio relacional profundo e manter a coerência global em designs de software complexos, superando a geração puramente sintática.

O benchmark e o código-fonte estão disponíveis publicamente para a comunidade de pesquisa.