VisCoder2: Building Multi-Language Visualization Coding Agents

Título: VisCoder2: Construindo Agentes de Codificação de Visualização Multilíngue

1. Problema e Motivação

Os Grandes Modelos de Linguagem (LLMs) têm demonstrado capacidade de gerar código para visualização de dados. No entanto, os modelos existentes enfrentam limitações críticas em fluxos de trabalho reais:

• Cobertura Limitada de Linguagens: A maioria dos conjuntos de dados e benchmarks foca exclusivamente em Python (bibliotecas como Matplotlib/Plotly) ou em especificações declarativas (Vega-Lite), ignorando linguagens simbólicas e específicas de domínio (como LaTeX, LilyPond, Asymptote).
• Falta de Validação Executável: Muitos dados de treinamento contêm snippets de código que não são executáveis ou não geram saídas visuais válidas.
• Ausência de Mecanismos Iterativos: Os benchmarks atuais avaliam predominantemente a geração em "um único turno" (one-shot), falhando em capturar a natureza iterativa do desenvolvimento real, onde analistas ajustam o código com base em erros de execução e inspeção visual.
• Falhas em Ambientes Reais: Agentes atuais frequentemente geram código que falha na execução, produz visualizações incorretas ou carecem de flexibilidade para corrigir erros em tempo de execução.

2. Metodologia e Recursos Propostos

Os autores introduzem um ecossistema completo composto por três recursos complementares para superar essas barreiras:

A. VisCode-Multi-679K (Conjunto de Dados)

• Escala e Diversidade: Um dataset supervisionado de grande escala contendo 679.000 amostras de visualização executáveis e diálogos de correção multi-turno.
• Cobertura de Linguagens: Abrange 12 linguagens de programação, incluindo Python, JavaScript, TypeScript, C++, R, HTML, SVG, LaTeX, LilyPond, Asymptote, Mermaid e Vega-Lite.
• Pipeline de Construção:
  1. Extração: Coleta de código de repositórios de código aberto (The-Stack-v2, svg-diagrams, CoSyn-400K).
  2. Validação em Tempo de Execução: Execução rigorosa em ambientes Jupyter isolados com filtros de erro (allow-errors=False). Apenas scripts que geram imagens válidas (não monocromáticas e >10KB) são mantidos.
  3. Geração de Instruções: Uso de LLMs para criar instruções naturais estruturadas (descrição de dados, estilo, setup e saída) para cada amostra validada.
  4. Diálogos de Correção: Integração de 66.000 diálogos multi-turno do dataset Code-Feedback para ensinar o modelo a revisar código falho com base em feedback de execução.

B. VisPlotBench (Benchmark)

• Objetivo: Uma avaliação sistemática de agentes de codificação de visualização.
• Estrutura: Contém 888 tarefas executáveis cobrindo 8 linguagens e 13 categorias visuais (incluindo barras, linhas, dispersão, hierarquias, mapas, música, redes, etc.).
• Protocolo de Avaliação:
  • Execução-Grounded: O código é executado em kernels específicos de linguagem.
  • Métricas: Execution Pass Rate (sucesso na execução), Task Score (aderência à instrução semântica) e Visual Score (similaridade perceptual com a referência).
  • Self-Debug: Suporte para avaliação de múltiplos rounds (até 3), onde o modelo recebe o log de erro e o código anterior para tentar corrigir a falha.

C. VisCoder2 (Modelos)

• Arquitetura: Uma família de modelos baseada no Qwen2.5-Coder (escalas de 3B, 7B, 14B e 32B parâmetros).
• Treinamento: Fine-tuning supervisionado utilizando o dataset VisCode-Multi-679K.
• Capacidade: Projetado para gerar, executar e depurar código iterativamente em ambientes diversos.

3. Resultados Principais

Os experimentos no VisPlotBench demonstraram avanços significativos:

• Desempenho Geral: O VisCoder2-32B alcançou uma taxa de execução geral de 82.4% após o processo de self-debug, superando significativamente as bases open-source de tamanho similar e aproximando-se do desempenho do modelo proprietário GPT-4.1 (que atingiu 82.4% no mesmo cenário).
• Vantagem em Linguagens Simbólicas: O modelo apresentou ganhos extraordinários em linguagens dependentes de compilador e sintaxe simbólica, onde as bases anteriores falhavam drasticamente:
  • LilyPond: A taxa de execução saltou de ~5% (base Qwen2.5-7B) para 69.1% (VisCoder2-7B) e 69.1% com self-debug.
  • LaTeX e Asymptote: Ganhos consistentes, superando o GPT-4.1-mini em várias configurações.
• Eficácia do Self-Debug: O mecanismo de correção iterativa foi crucial, aumentando a taxa de execução em quase 10 pontos percentuais em média para os modelos maiores, especialmente corrigindo erros estruturais e de sintaxe em linguagens complexas.
• Ablação de Dados: O estudo mostrou que a combinação de dados sintéticos (CoSyn) e dados naturais (The-Stack) é essencial. Dados sintéticos cobriram lacunas em linguagens simbólicas, enquanto os diálogos de Code-Feedback foram vitais para a capacidade de recuperação (debug).

4. Análise de Erros e Limitações

• Tipos de Erros: O self-debug é altamente eficaz para erros estruturais (sintaxe, chamadas de função inválidas) e de interface. No entanto, erros semânticos profundos (variáveis não definidas logicamente) e erros de ambiente de renderização (falhas de pacotes de compilação) permanecem difíceis de resolver apenas com feedback de log.
• Desacoplamento Execução-Semântica: Em linguagens como LaTeX e SVG, é possível obter alta taxa de execução (o código compila), mas baixa pontuação visual (o resultado não corresponde à intenção), indicando que a execução bem-sucedida não garante a qualidade visual perfeita.
• Limitações do Dataset: O corpus ainda é desbalanceado, com Python e Vega-Lite bem representados, enquanto linguagens de nicho têm menos amostras, o que pode enviesar o modelo.

5. Significado e Impacto

O trabalho VisCoder2 estabelece um novo marco na área de agentes de codificação para visualização de dados:

1. Padrão Multilíngue: É a primeira iniciativa a fornecer um dataset e benchmark unificados para 12 linguagens, incluindo as mais complexas e simbólicas.
2. Validação Realista: Ao focar em código executável e em ciclos de debug iterativo, o trabalho alinha o treinamento de LLMs com o fluxo de trabalho real de cientistas de dados e analistas.
3. Competitividade Open-Source: Demonstra que modelos open-source, quando treinados com dados de alta qualidade e validados por execução, podem rivalizar com modelos proprietários de ponta em tarefas especializadas.
4. Futuro: Abre caminho para assistentes de codificação mais robustos capazes de operar em ecossistemas de visualização diversos, reduzindo a barreira de entrada para a criação de gráficos complexos e científicos.

Em resumo, o artigo prova que a combinação de dados massivos e validados, benchmarks rigorosos com feedback de execução e treinamento em correção iterativa é a chave para construir agentes de visualização confiáveis e generalistas.