En el Módulo 10 convertimos una imagen en una secuencia de tokens con el ViT. Guarda bien esa idea, porque es el puente que cruzaremos hoy. Un LLM —el Transformer del otro curso— nació ciego: solo sabe procesar tokens de texto. Y sin embargo hoy le mandas una foto y te la describe, te lee un gráfico, te explica un meme. ¿Cómo aprendió a ver un modelo que solo entiende palabras? La respuesta es más simple de lo que parece, y usa exactamente las piezas que ya tienes en la mano.

La tesis del módulo

Un LLM no aprende a ver imágenes: aprende a leer tokens que casualmente vinieron de una imagen. Un vision encoder convierte la foto en vectores, una proyección los disfraza de tokens que el LLM entiende, y esos “tokens visuales” entran a su contexto junto al texto. El LLM sigue haciendo lo único que sabe — predecir el siguiente token — pero ahora con los ojos puestos.

El truco central: hablar el idioma del LLM

Un LLM trabaja con vectores de un tamaño fijo —su espacio de tokens, digamos 4096 dimensiones—. Todo lo que entra a su contexto tiene que hablar ese idioma. El texto ya lo habla: cada palabra se vuelve un embedding de 4096. Una imagen, no. Hay que traducirla, y eso se hace en tres pasos:

Vision encoder. La imagen pasa por un ViT o por la mitad-imagen de CLIP (los del Módulo 10 y el Módulo 9). Sale convertida en un puñado de embeddings visuales —pero en su tamaño, no el del LLM.
Proyección. Una capa —a veces una simple matriz, a veces un mini-MLP— toma esos embeddings visuales y los proyecta al tamaño exacto del espacio de tokens del LLM. Es el adaptador de corriente entre dos mundos. Después de esto, un embedding de imagen es indistinguible, en forma, de un embedding de palabra.
Al contexto. Esos “tokens visuales” se meten en la secuencia de entrada del LLM, mezclados con los tokens del texto del usuario. El LLM procesa todo junto con su self-attention de siempre y responde token a token.

En código, el patrón estilo LLaVA es sorprendentemente corto: la única pieza nueva es la proyección, y el “meter al contexto” es literalmente concatenar dos secuencias de embeddings.

import torch
import torch.nn as nn

# La ÚNICA pieza nueva: adapta el tamaño del vision encoder
# (p.ej. 1024) al espacio de tokens del LLM (p.ej. 4096).
proyeccion = nn.Linear(1024, 4096)

# 1) el vision encoder ya masticó la imagen -> embeddings visuales
emb_visual = vision_encoder(imagen)        # (n_parches, 1024)

# 2) la proyección los disfraza de tokens que el LLM entiende
tok_visuales = proyeccion(emb_visual)      # (n_parches, 4096)

# 3) el texto se vuelve embeddings en el MISMO espacio de 4096
tok_texto = llm.embed(tokenizar("¿qué ves aquí?"))   # (n_tok, 4096)

# 'meter al contexto' = concatenar las dos secuencias y pasarlas
# al LLM tal cual. Para él, todo es una secuencia de tokens.
entrada = torch.cat([tok_visuales, tok_texto], dim=0)
respuesta = llm.generar(entrada)

Fíjate en lo poco que cambió: el LLM sigue recibiendo una secuencia de vectores de 4096 y generando texto. La imagen entró disfrazada, no como algo especial.

   imagen            texto del usuario
     │                     │
     ▼                     │
   ┌──────────────┐        │
   │ vision       │        │
   │ encoder      │        │
   │ (ViT / CLIP) │        │
   └──────────────┘        │
     │ embeddings          │
     │ visuales            │
     ▼                     │
   ┌──────────────┐        │
   │  proyección  │        │
   └──────────────┘        │
     │ tokens visuales     │ tokens de texto
     │                     │
     ▼                     ▼
   ┌─────────────────────────────────┐
   │   contexto del LLM (Transformer)│
   │   [img][img]...[¿qué ves aquí?] │
   └─────────────────────────────────┘
                   │
                   ▼
              respuesta

Lo elegante: el LLM no fue rediseñado. Sigue siendo el mismo Transformer que predice el siguiente token. Solo le cambiaron la dieta de entrada. Por eso la comunidad pudo “darle ojos” a modelos de texto ya existentes sin entrenarlos de cero.

Los enfoques que existen

No todos los modelos multimodales se arman igual. Hay tres familias que conviene distinguir:

CLIP a secas. El más viejo y el más limitado. CLIP alinea texto e imágenes en un espacio común, así que sirve para comparar (“¿esta foto se parece a esta frase?”) o buscar imágenes por texto. Pero CLIP no genera lenguaje: no te describe la foto, solo te dice qué tan cerca está de una frase dada. Es un cimiento, no un conversador.

Estilo LLaVA (encoder + proyección + LLM). El patrón modular que describimos arriba, y el más transparente para entender. Se toma un vision encoder pre-entrenado (CLIP), un LLM de texto pre-entrenado, y se entrena solo la proyección en el medio (a veces también un poco del LLM). Barato y efectivo: reutiliza dos modelos que ya existían. La mayoría de los modelos multimodales abiertos siguen esta receta.

Nativos multimodales (GPT-4o en adelante, Claude, Gemini). Los modelos de frontera de OpenAI, Anthropic y Google aceptan imágenes y texto de forma integrada, y en general se entrenan sobre ambas modalidades desde etapas tempranas, no pegando piezas al final. Sus detalles internos son propietarios y no están publicados, así que aquí me quedo en lo que se sabe con certeza: reciben imagen y texto en el mismo contexto y razonan sobre ambos. No voy a inventar cómo están cableados por dentro — nadie fuera de esas empresas lo sabe con precisión.

Enfoque	Cómo se arma	Genera texto	Nota
CLIP	Encoder texto + encoder imagen	No	Compara y busca, no conversa
LLaVA	Encoder + proyección + LLM	Sí	Modular, reutiliza modelos; abierto
Nativo (GPT-4o, Claude, Gemini)	Entrenado multimodal integrado	Sí	Frontera; interna propietaria

Ojo: que un LLM “vea” no significa que vea como tú. Procesa la imagen como tokens y razona sobre ellos con lenguaje; puede describir con lujo de detalle una foto y a la vez errarle a un conteo simple de objetos o a la posición exacta de algo. No hay percepción visual real detrás — hay tokens y estadística.

Dónde se cruzan los dos cursos

Este módulo es literalmente el puente entre las dos series de la academia:

El vision encoder es el ViT del Módulo 10 de este curso.
El LLM es el Transformer del curso de Transformers, el mismo que aprende a predecir el siguiente token.
La proyección es la costura entre ambos: convierte “tokens de imagen” en algo que el LLM ya sabe procesar.

Un modelo multimodal es, entonces, tu curso de generación de imágenes y tu curso de Transformers dándose la mano. El ViT ve, el Transformer razona, y una humilde capa lineal los presenta.

Errores comunes

Creer que el LLM procesa píxeles. Nunca ve un píxel: ve los embeddings que el vision encoder ya masticó y la proyección disfrazó de tokens.
Pensar que “ve” como un humano. Razona sobre tokens visuales con lenguaje; por eso a veces describe de maravilla y a la vez cuenta mal objetos o confunde izquierda con derecha.
Confundir CLIP con un modelo que describe. CLIP compara texto e imagen; no genera descripciones. Para que te cuente qué hay hace falta un LLM detrás (estilo LLaVA o nativo).
Suponer que sabemos cómo funciona GPT-4o o Gemini por dentro. No lo sabemos: su arquitectura interna es propietaria. Cualquier “explicación” detallada de sus tripas es especulación.
Olvidar que las imágenes consumen contexto. Los tokens visuales ocupan lugar en la ventana de contexto igual que el texto: una imagen grande puede gastar más de mil tokens.

La frase para llevarse

“Darle ojos a un LLM no es rediseñarlo: es ponerle un ViT delante y una capa de proyección que traduzca lo que ve al único idioma que el modelo entiende — tokens. El ViT mira, el Transformer piensa, la proyección los presenta.”

Qué viene

Módulo 12: práctica, producción, límites y ética. Cierre del curso. Bajamos de la teoría a las manos: las herramientas reales (diffusers, ComfyUI, APIs), las perillas que de verdad se tocan, extensiones como ControlNet y LoRA, y —con la seriedad que merece— los límites técnicos y las preguntas éticas que todo esto abre.

Generación de imágenes — Módulo 11: multimodal — cómo ven los LLM