Como Avaliar Modelos de Visão Multimodal com o PerceptionBench da Moonshot AI

Por que avaliar modelos de visão multimodal virou prioridade em 2026

Até pouco tempo atrás, avaliar um modelo de visão significava rodar um punhado de datasets clássicos — ImageNet, COCO, VQA — e torcer para que o número subisse. Em 2026, essa abordagem não cola mais. Modelos como GPT-4o, Gemini 2.5 Flash e Claude 4 precisam ser testados em percepção visual de granularidade fina: conseguir contar objetos em uma cena lotada, detectar quando um texto foi alterado, comparar profundidades ou perceber que uma pergunta contém uma premissa falsa. É exatamente para isso que a Moonshot AI criou o PerceptionBench.

Este tutorial mostra como construir um pipeline completo de avaliação usando o PerceptionBench — do carregamento resiliente do dataset (que pesa 1,63 GB) até a exportação de relatórios com intervalos de confiança bootstrap. Você vai aprender a usar três backends diferentes: uma baseline cega (sem visão), APIs compatíveis com OpenAI e modelos locais do Hugging Face. Tudo pode rodar em um Google Colab gratuito, sem GPU paga.

✅ O que você ganha

• Avaliação multimodal realista: o benchmark cobre 10 capacidades atômicas — OCR, contagem, localização, raciocínio contextual, comparação, percepção de profundidade, detecção de alucinação e mais.
• Pipeline reproduzível: cada execução gera JSONL, CSV e JSON com metadados de configuração, tornando os resultados auditáveis.
• Três backends intercambiáveis: baseline cega (sem custo), API OpenAI (qualquer provider compatível) e modelos locais do Hugging Face.
• Julgamento automatizado: o sistema extrai e normaliza respostas numéricas, booleanas e textuais, aplicando regras ou LLM como juiz.
• Análise estatística robusta: bootstrap confidence intervals, slices por dificuldade, perfis de capacidade e comparação com o leaderboard oficial.

⚠️ Limitações honestas

• Não substitui avaliação humana: o julgamento baseado em regras pode falhar em respostas criativas ou ambíguas.
• Dataset em inglês: as perguntas e respostas estão em inglês; modelos otimizados para português podem ser prejudicados.
• Requer download de ~1,63 GB: em conexões lentas, o carregamento completo pode levar vários minutos.

📋 Requisitos

🛠️ Passo a passo

1. Configurando o ambiente no Google Colab

O primeiro bloco de código instala todas as dependências e define as configurações globais. A estrutura usa um dicionário CFG que centraliza parâmetros como o repositório do dataset (moonshotai/PerceptionBench), o split (train), quantos exemplos por categoria (12) e qual backend usar (blind, api ou local).

Por que isso importa: centralizar a configuração em um dicionário Python permite trocar de backend ou dataset com uma única linha, sem caçar strings espalhadas pelo código. É um padrão que todo projeto de avaliação deveria adotar.

CFG = dict(
   REPO            = "moonshotai/PerceptionBench",
   SPLIT           = "train",
   N_PER_CATEGORY  = 12,
   MAX_SCAN        = 1200,
   BACKEND         = "blind",    # "blind", "api" ou "local"
   API_BASE        = "https://api.openai.com/v1",
   API_MODEL       = "gpt-4o-mini",
   LOCAL_MODEL     = "HuggingFaceTB/SmolVLM2-2.2B-Instruct",
   JUDGE           = "rule",
   OUT_DIR         = "./perceptionbench_out",
)

2. Carregamento estratificado do dataset

O PerceptionBench tem ~1,63 GB. Em vez de baixar tudo, o pipeline tenta três estratégias em cascata: (1) streaming de arquivos Parquet convertidos via Hugging Face Hub, (2) streaming dos arquivos originais, (3) download completo como último recurso.

A amostragem é estratificada por capacidade — cada uma das 10 categorias (error_category) contribui com exatamente N_PER_CATEGORY exemplos. Isso garante que o score final não seja distorcido por um desbalanceamento acidental do shard.

3. Decodificação e normalização de imagens

O dataset armazena imagens em formatos variados: data URIs, strings base64 puras, byte arrays, objetos PIL e dicionários do Hugging Face. O pipeline normaliza tudo para RGB consistente, extrai placeholders do texto da pergunta (como <image_1>) e monta registros estruturados com questão, respostas, imagens, capacidade, dimensões e fonte original.

4. Construção do prompt multimodal

Um system prompt rigoroso instrui o modelo a inspecionar todas as imagens e retornar apenas a resposta final em formato padronizado. As imagens são redimensionadas para no máximo 1024px no lado maior e inseridas como image_url no formato OpenAI. O posicionamento relativo das imagens em relação aos placeholders do texto é preservado.

5. Backends de inferência

O pipeline suporta três backends intercambiáveis:

• Blind-prior: responde sem ver as imagens — serve como baseline para medir o quanto a visão realmente ajuda.
• API OpenAI-compatível: funciona com OpenAI, Groq, Together, DeepSeek e qualquer provider que exponha /v1/chat/completions. Suporta paralelismo com ThreadPoolExecutor.
• Local Hugging Face: carrega modelos como SmolVLM2-2.2B diretamente com transformers, sem chamadas de rede.

6. Extração e normalização de respostas

Modelos respondem de formas imprevisíveis — “42”, “forty two”, “The answer is 42.”, “42.0”. O normalizador converte números por extenso (num2words), remove pontuação, lida com booleanos e extrai frases curtas. O julgamento baseado em regras compara com a resposta de referência usando tolerância numérica configurável (NUM_REL_TOL).

7. Análise e exportação

Após a execução, o pipeline gera: acurácia geral e por capacidade, intervalos de confiança bootstrap (95%), slices por dificuldade (easy, medium, hard), exemplos de falha, comparação com o leaderboard oficial e visualizações de perfil de capacidade. Tudo exportado como JSONL, CSV e JSON.

📊 Comparação entre backends

💼 Casos de uso reais

• Comparação de fornecedores de API: rode o mesmo benchmark contra GPT-4o, Gemini e Claude para decidir qual usar em produção com dados visuais.
• Fine-tuning com visão: avalie o modelo antes e depois do fine-tuning para quantificar o ganho real por capacidade visual.
• Regressão em pipelines CI/CD: integre o benchmark no GitHub Actions para detectar degradação de percepção visual a cada novo release do modelo.
• Pesquisa acadêmica: use os intervalos de confiança bootstrap e slices de dificuldade para produzir tabelas e gráficos prontos para publicação.
• Seleção de modelo para chatbot com imagens: simule o comportamento do seu sistema em produção testando com perguntas que incluem múltiplas imagens.

💰 Comparação de custo

🔧 Troubleshooting

• ❌ datasets não instala no Colab: O ambiente do Colab às vezes tem versões conflitantes do pyarrow. Solução: execute !pip install --upgrade pyarrow datasets antes do script principal.
• ❌ Streaming de Parquet falha com FileNotFoundError: O branch refs/convert/parquet pode não estar disponível para todos os datasets. O fallback automático para streaming JSON ou download completo resolve isso — o log mostrará [load] parquet stream unavailable; falling back.
• ❌ CUDA out of memory no backend local: Reduza MAX_IMAGE_SIDE para 512 e desabilite SHOW_PLOTS. Modelos como SmolVLM2-2.2B cabem em 4 GB VRAM.
• ❌ API retorna HTTP 429 (rate limit): Reduza API_WORKERS para 1 e adicione time.sleep(2) entre as chamadas. APIs gratuitas (Groq) têm limites mais agressivos.
• ❌ Julgamento rule rejeita resposta correta com formatação diferente: Respostas como “42.0” vs “42” já são tratadas pela tolerância numérica. Para casos extremos (ex: “about forty two”), mude JUDGE para "llm" e configure JUDGE_MODEL.
• ❌ UnicodeDecodeError ao decodificar imagens base64: Algumas entradas do dataset usam data URIs com prefixo data:image/jpeg;base64,. O _decode_image() já lida com isso, mas se falhar, verifique se a string tem padding = correto.

❓ FAQ

• Preciso de GPU para rodar o benchmark? Não. O backend blind e o backend api rodam em CPU. Apenas o backend local se beneficia de GPU, mas modelos pequenos como SmolVLM2-2.2B rodam em CPU com desempenho aceitável.
• Posso usar com modelos da DeepSeek ou Groq? Sim. Qualquer API compatível com o formato OpenAI (/v1/chat/completions) funciona. Basta mudar API_BASE e API_MODEL.
• O benchmark cobre vídeos? Não. O PerceptionBench é focado em imagens estáticas. Para vídeo, veja benchmarks como Video-MME ou MLVU.
• Como adiciono meu próprio modelo? Herde da classe base do backend e implemente generate(messages). O resto do pipeline (julgamento, análise, exportação) funciona automaticamente.
• Os resultados são comparáveis ao leaderboard oficial? Sim, se você usar o split train completo. O tutorial usa uma amostra estratificada para velocidade; para submissão oficial, use o dataset completo.
• Posso rodar em português? O dataset está em inglês, mas você pode usar um modelo de visão multilíngue (como Qwen2-VL) e traduzir as perguntas via API antes da inferência.

🚀 O futuro da avaliação multimodal

O PerceptionBench representa uma mudança de mentalidade: em vez de tratar “visão” como uma capacidade monolítica (um único número de acurácia), ele a decompõe em 10 habilidades atômicas — contagem, localização, OCR, raciocínio contextual, profundidade, etc. Isso permite diagnósticos muito mais precisos: descobrir que seu modelo conta perfeitamente mas alucina profundidade é infinitamente mais útil do que saber que ele tem “78% de acurácia visual”.

Em 2027, a tendência é que benchmarks modulares como este se tornem o padrão da indústria, substituindo os datasets monolíticos da década passada. O pipeline que você construiu hoje é a fundação para acompanhar essa evolução — adicionar uma nova capacidade de avaliação será tão simples quanto incluir uma nova categoria no dicionário de configuração.