Modelos de Visión-Lenguaje — El Patrón ViT-MLP-LLM

flowchart LR
    IMG["Imagen<br/>(H x W x 3)"] --> ViT["Codificador de vision<br/>(ViT, CLIP-L,<br/>SigLIP, DINOv3)"]
    ViT --> FEATS["Tokens de imagen<br/>(N, d_vit)"]
    FEATS --> PROJ["Proyector<br/>(MLP de 2-4 capas<br/>o Q-former)"]
    PROJ --> VTOK["Tokens de imagen<br/>en espacio del LLM<br/>(N, d_llm)"]
    TXT["Prompt de texto"] --> TOK["Tokenizador del LLM"]
    TOK --> TTOK["Tokens de texto<br/>(M, d_llm)"]
    VTOK --> CONCAT["Intercalar<br/>o concatenar"]
    TTOK --> CONCAT
    CONCAT --> LLM["LLM decoder<br/>(Qwen3, LLaMA, etc.)"]
    LLM --> OUT["Respuesta en texto"]

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

CMER = fraccion de salidas donde la confianza del texto es alta pero la similitud imagen-texto (via un verificador de la familia CLIP) es baja

00-$5.000 en cómputo, 2-10 horas de entrenamiento.

El razonamiento espacial sigue siendo débil

Los VLMs actuales puntúan 50-60% en benchmarks de razonamiento espacial (arriba-abajo, izquierda-derecha, conteo, distancia). Si tu caso de uso depende de "qué objeto está encima de cuál", valida intensamente — el rendimiento de un VLM genérico está por debajo del humano. Alternativas mejores que un VLM para tareas puramente espaciales: un estimador especializado de keypoint / pose, un modelo de profundidad, o un modelo de detección con geometría de bounding box posprocesada.

Constrúyelo

Paso 1: El proyector

La parte que entrenarás con más frecuencia. MLP de 2-4 capas con 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)

La entrada es un tensor de tokens (N_patches, d_vit). La salida es (N_patches, d_llm). El LLM trata cada fila de salida como un token más.

Paso 2: Ensamblar el ViT-MLP-LLM de extremo a extremo

Esqueleto del forward pass para un VLM mínimo. El código real usa transformers; este es el layout conceptual.

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

El token placeholder <image> en el texto es reemplazado por embeddings reales de imagen — el mismo patrón que usan LLaVA, Qwen-VL e InternVL.

Paso 3: Cálculo de la CMER

Una verificación ligera en tiempo de ejecución.

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()

Trata la CMER como un KPI de producción. Monitoréala por endpoint, por tipo de prompt, por cliente. Una CMER creciente indica que el modelo está empezando a alucinar sobre alguna distribución de entrada.

Paso 4: Clasificador VLM de juguete (ejecutable)

Demuestra que el proyector entrena. "Características de ViT" falsas entran; un pequeño token estilo LLM predice una clase.

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)

Se puede ajustar esto sobre pares sintéticos (característica, clase) en menos de 200 pasos — suficiente para mostrar que el patrón del proyector funciona.

Úsalo

Tres maneras en que los equipos de producción usan VLMs en 2026:

• API alojada — OpenAI Vision, Anthropic Claude Vision, Google Gemini Vision. Cero infraestructura, riesgo de proveedor.
• Self-host open-source — Qwen3-VL o InternVL3.5 vía transformers y vllm. Control total, mayor esfuerzo inicial.
• Fine-tune en el dominio — carga Qwen2.5-VL-7B o LLaVA-1.6-7B, haz LoRA sobre 5k-50k ejemplos custom, sírvelo con vllm o 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)

apply_chat_template oculta la tokenización del placeholder <image>; el modelo maneja el merge internamente.

Entrégalo

Esta lección produce:

• outputs/prompt-vlm-selector.md — elige Qwen3-VL / InternVL3.5 / LLaVA-Next / API dadas la precisión, latencia, longitud de contexto y presupuesto.
• outputs/skill-cmer-monitor.md — emite el código para instrumentar un endpoint de VLM de producción con cross-modal error rate, dashboards por endpoint y umbrales de alerta.

Ejercicios

1. (Fácil) Ejecuta tres prompts ("¿qué es esto?", "cuenta los objetos", "describe la escena") a través de cualquier VLM abierto sobre cinco imágenes. Puntúa cada respuesta como correcta / parcialmente correcta / alucinada a mano. Calcula una tasa de primera pasada similar a la CMER.
2. (Medio) Haz fine-tune de Qwen2.5-VL-3B o LLaVA-1.6-7B con LoRA (rank 16) sobre 500 imágenes de un dominio objetivo con leyendas. Compara la precisión estilo MMBench zero-shot vs. con fine-tune.
3. (Difícil) Reemplaza el codificador de imagen del VLM con DINOv3 en lugar de su SigLIP/CLIP por defecto. Reentrena solo el proyector (LLM congelado + DINOv3 congelado). Mide si las tareas de predicción densa (conteo, razonamiento espacial) mejoran.

Términos Clave

Término	Lo que la gente dice	Lo que realmente significa
ViT-MLP-LLM	"El patrón VLM"	Codificador de visión + proyector + modelo de lenguaje; todo VLM de 2026
Proyector	"El puente"	MLP de 2-4 capas (o Q-former) que mapea tokens de visión al espacio de embedding del LLM
DeepStack	"El truco de características de Qwen3-VL"	Características multinivel del ViT apiladas en lugar de solo la última capa
Token de imagen	"Placeholder "	Token especial en el flujo de texto reemplazado por embeddings de visión proyectados
CMER	"KPI de alucinación"	Cross-Modal Error Rate; alta cuando la confianza del texto es alta pero la similitud imagen-texto es baja
Agente visual	"VLM que hace clic"	VLM operando GUIs (OSWorld, móvil, web) con llamadas a herramientas
Q-former	"Puente de tokens de conteo fijo"	Proyector estilo BLIP-2 que produce un número fijo de tokens de consulta visual
Alineación / preentrenamiento / instruction tuning	"Tres etapas"	Pipeline estándar de entrenamiento de VLM

Lectura 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)