Modelos de Visão-Linguagem — O Padrão ViT-MLP-LLM

flowchart LR
    IMG["Imagem<br/>(H x W x 3)"] --> ViT["Codificador de visão<br/>(ViT, CLIP-L,<br/>SigLIP, DINOv3)"]
    ViT --> FEATS["Tokens de imagem<br/>(N, d_vit)"]
    FEATS --> PROJ["Projetor<br/>(MLP de 2-4 camadas<br/>ou Q-former)"]
    PROJ --> VTOK["Tokens de imagem<br/>no espaco do LLM<br/>(N, d_llm)"]
    TXT["Prompt de texto"] --> TOK["Tokenizador do LLM"]
    TOK --> TTOK["Tokens de texto<br/>(M, d_llm)"]
    VTOK --> CONCAT["Intercalar<br/>ou concatenar"]
    TTOK --> CONCAT
    CONCAT --> LLM["LLM decoder<br/>(Qwen3, LLaMA, etc.)"]
    LLM --> OUT["Resposta em texto"]

    style ViT fill:#dbeafe,stroke:#2563eb
    style PROJ fill:#fef3c7,stroke:#d97706
    style LLM fill:#dcfce7,stroke:#16a34a

CMER = fracao de saidas onde a confianca do texto e alta mas a similaridade imagem-texto (via um verificador da familia CLIP) e baixa

00-$5.000 em computação, 2-10 horas de treinamento.

O raciocínio espacial ainda é fraco

Os VLMs atuais pontuam 50-60% em benchmarks de raciocínio espacial (acima-abaixo, esquerda-direita, contagem, distância). Se seu caso de uso depende de "qual objeto está em cima de qual", valide intensamente — o desempenho de VLM genérico está abaixo do humano. Alternativas melhores que VLMs para tarefas puramente espaciais: um estimador especializado de keypoint / pose, um modelo de profundidade, ou um modelo de detecção com geometria de bounding box pós-processada.

Construa

Passo 1: O projetor

A parte que você treinará com mais frequência. MLP de 2-4 camadas com GELU.

import torch
import torch.nn as nn


class Projector(nn.Module):
    def __init__(self, vit_dim=768, llm_dim=4096, hidden=4096):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(vit_dim, hidden),
            nn.GELU(),
            nn.Linear(hidden, llm_dim),
        )

    def forward(self, x):
        return self.net(x)

A entrada é um tensor de tokens (N_patches, d_vit). A saída é (N_patches, d_llm). O LLM trata cada linha de saída apenas como mais um token.

Passo 2: Montar o ViT-MLP-LLM de ponta a ponta

Esqueleto do forward pass para um VLM mínimo. Código real usa transformers; este é o layout conceitual.

class MinimalVLM(nn.Module):
    def __init__(self, vit, projector, llm, image_token_id):
        super().__init__()
        self.vit = vit
        self.projector = projector
        self.llm = llm
        self.image_token_id = image_token_id  # placeholder token in text prompt

    def forward(self, image, input_ids, attention_mask):
        # 1. vision features
        vision_tokens = self.vit(image)                     # (B, N_patches, d_vit)
        vision_embeds = self.projector(vision_tokens)       # (B, N_patches, d_llm)

        # 2. text embeddings
        text_embeds = self.llm.get_input_embeddings()(input_ids)  # (B, M, d_llm)

        # 3. replace image placeholder tokens with vision embeds
        merged = self._merge(text_embeds, vision_embeds, input_ids)

        # 4. run LLM
        return self.llm(inputs_embeds=merged, attention_mask=attention_mask)

    def _merge(self, text_embeds, vision_embeds, input_ids):
        out = text_embeds.clone()
        expected = vision_embeds.size(1)
        for b in range(input_ids.size(0)):
            positions = (input_ids[b] == self.image_token_id).nonzero(as_tuple=True)[0]
            if len(positions) != expected:
                raise ValueError(
                    f"batch item {b} has {len(positions)} image tokens but vision_embeds has {expected} patches."
                    " Every sample in the batch must be pre-padded to the same number of image placeholder tokens.")
            out[b, positions] = vision_embeds[b]
        return out

O token placeholder <image> no texto é substituído por embeddings reais de imagem — mesmo padrão que LLaVA, Qwen-VL e InternVL usam.

Passo 3: Cálculo da CMER

Uma verificação leve em tempo de execução.

import torch.nn.functional as F


def cross_modal_error_rate(image_emb, text_emb, text_confidence, sim_threshold=0.25, conf_threshold=0.8):
    """
    image_emb, text_emb: embeddings of image and generated text (normalised internally)
    text_confidence:     mean per-token probability in [0, 1]
    Returns:             fraction of high-confidence outputs with low image-text alignment
    """
    image_emb = F.normalize(image_emb, dim=-1)
    text_emb = F.normalize(text_emb, dim=-1)
    sim = (image_emb * text_emb).sum(dim=-1)        # cosine similarity
    high_conf_low_sim = (text_confidence > conf_threshold) & (sim < sim_threshold)
    return high_conf_low_sim.float().mean().item()

Trate a CMER como um KPI de produção. Monitore-a por endpoint, por tipo de prompt, por cliente. Uma CMER crescente indica que o modelo está começando a alucinar em alguma distribuição de entrada.

Passo 4: Classificador VLM de brinquedo (executável)

Demonstra que o projetor treina. "Características de ViT" falsas entram; um pequeno token estilo LLM prevê uma classe.

class ToyVLM(nn.Module):
    def __init__(self, vit_dim=32, llm_dim=64, num_classes=5):
        super().__init__()
        self.projector = Projector(vit_dim, llm_dim, hidden=64)
        self.head = nn.Linear(llm_dim, num_classes)

    def forward(self, vision_tokens):
        projected = self.projector(vision_tokens)
        pooled = projected.mean(dim=1)
        return self.head(pooled)

É possível ajustar isso em pares sintéticos (característica, classe) em menos de 200 passos — o suficiente para mostrar que o padrão do projetor funciona.

Use

Três maneiras pelas quais equipes de produção usam VLMs em 2026:

• API hospedada — OpenAI Vision, Anthropic Claude Vision, Google Gemini Vision. Zero infraestrutura, risco de fornecedor.
• Self-host open-source — Qwen3-VL ou InternVL3.5 via transformers e vllm. Controle total, maior esforço inicial.
• Fine-tune no domínio — carregue Qwen2.5-VL-7B ou LLaVA-1.6-7B, faça LoRA em 5k-50k exemplos custom, sirva com vllm ou TGI.

from transformers import AutoProcessor, AutoModelForVision2Seq
import torch
from PIL import Image

model_id = "Qwen/Qwen3-VL-8B-Instruct"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForVision2Seq.from_pretrained(model_id, torch_dtype=torch.bfloat16, device_map="auto")

messages = [{
    "role": "user",
    "content": [
        {"type": "image", "image": Image.open("plot.png")},
        {"type": "text", "text": "What does this chart show?"},
    ],
}]
inputs = processor.apply_chat_template(messages, add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors="pt").to("cuda")
generated = model.generate(**inputs, max_new_tokens=256)
answer = processor.decode(generated[0][inputs["input_ids"].shape[1]:], skip_special_tokens=True)

O apply_chat_template esconde a tokenização do placeholder <image>; o modelo lida com o merge internamente.

Entregue

Esta lição produz:

• outputs/prompt-vlm-selector.md — escolhe Qwen3-VL / InternVL3.5 / LLaVA-Next / API dadas acurácia, latência, comprimento de contexto e orçamento.
• outputs/skill-cmer-monitor.md — emite o código para instrumentar um endpoint de VLM de produção com cross-modal error rate, dashboards por endpoint e limiares de alerta.

Exercícios

1. (Fácil) Rode três prompts ("o que é isto?", "conte os objetos", "descreva a cena") através de qualquer VLM aberto em cinco imagens. Pontue cada resposta como correta / parcialmente correta / alucinada à mão. Calcule uma taxa de primeira passagem semelhante à CMER.
2. (Médio) Faça fine-tune do Qwen2.5-VL-3B ou LLaVA-1.6-7B com LoRA (rank 16) em 500 imagens de um domínio-alvo com legendas. Compare a acurácia estilo MMBench zero-shot vs. com fine-tune.
3. (Difícil) Substitua o codificador de imagem do VLM por DINOv3 em vez de seu SigLIP/CLIP padrão. Re-treine apenas o projetor (LLM congelado + DINOv3 congelado). Meça se as tarefas de predição densa (contagem, raciocínio espacial) melhoram.

Termos-Chave

Termo	O que as pessoas dizem	O que realmente significa
ViT-MLP-LLM	"O padrão VLM"	Codificador de visão + projetor + modelo de linguagem; todo VLM de 2026
Projetor	"A ponte"	MLP de 2-4 camadas (ou Q-former) que mapeia tokens de visão para o espaço de embedding do LLM
DeepStack	"O truque de características do Qwen3-VL"	Características multi-nível do ViT empilhadas em vez de apenas a última camada
Token de imagem	"Placeholder "	Token especial no fluxo de texto substituído por embeddings de visão projetados
CMER	"KPI de alucinação"	Cross-Modal Error Rate; alta quando a confiança do texto é alta mas a similaridade imagem-texto é baixa
Agente visual	"VLM que clica"	VLM operando GUIs (OSWorld, mobile, web) com chamadas de ferramenta
Q-former	"Ponte de tokens de contagem fixa"	Projetor estilo BLIP-2 que produz um número fixo de tokens de consulta visual
Alinhamento / pré-treinamento / instruction tuning	"Três estágios"	Pipeline padrão de treinamento de VLM

Leitura Adicional

• Qwen3-VL Technical Report (arXiv 2511.21631)
• InternVL3.5 Advancing Open-Source Multimodal Models (arXiv 2508.18265)
• LLaVA-Next series
• BentoML: Best Open-Source VLMs 2026
• MMMU: Multi-discipline Multimodal Understanding benchmark
• VLMs in manufacturing (Robotics Tomorrow, March 2026)