tl;dr Toda la IA generativa se reduce a una idea: aprender la distribución de probabilidad de los datos, $P(x)$, y luego muestrear de ella. Los LLMs lo hacen factorizando esa distribución token a token; los modelos de difusión, aprendiendo a revertir un proceso de ruido. El resto — temperatura, top-p, RLHF, KV cache — son detalles de ingeniería sobre esa idea. Aquí los desarmamos uno por uno.

“Generativa” se ha vuelto un prefijo de marketing, pero tiene un significado técnico preciso que vale la pena recuperar. En el artículo anterior recorrimos la cadena desde la neurona hasta el LLM; en este vamos un nivel más profundo: ¿qué hace que un modelo sea generativo? ¿Por qué un mismo prompt produce respuestas distintas? ¿Qué ocurre, paso a paso, entre que pulsas Enter y aparece el primer token?

Manifiesto de ética de siempre: los modelos generativos producen muestras plausibles de una distribución, no verdades verificadas. Eso es una propiedad matemática, no un bug. Diseña y consume con esa premisa. Referencias al final, como corresponde.

Si prefieres una primera pasada visual antes de entrar al texto, este video de Henrik Kniberg resume el panorama de forma muy clara:

---

La definición técnica: modelar $P(x)$

En machine learning clásico distinguimos dos familias de modelos:

	Modelo discriminativo	Modelo generativo
Aprende	$P(y \mid x)$ — la frontera entre clases	$P(x)$ — la distribución de los datos
Responde	”¿Esto es spam o no?"	"Genérame un correo plausible”
Ejemplo	Regresión logística, clasificador de imágenes	LLM, Stable Diffusion, generador de audio

Un modelo generativo aprende cómo se distribuyen los datos en su espacio: qué secuencias de palabras son probables en español, qué configuraciones de píxeles forman caras humanas, qué formas de onda suenan a voz. Una vez aprendida esa distribución (o una aproximación), generar es muestrear: sacar un punto nuevo que sea estadísticamente coherente con lo visto durante el entrenamiento.

El problema es que $P(x)$ es un objeto monstruoso. Para un texto de 1.000 tokens con un vocabulario de 100K, el espacio de secuencias posibles es $100{.}000^{1000}$. Nadie modela eso directamente. Toda la historia técnica de la IA generativa es la historia de cómo factorizar o aproximar esa distribución de forma tratable. Hay dos estrategias dominantes hoy.

Estrategia 1: factorización autoregresiva (los LLMs)

La regla de la cadena de probabilidad permite descomponer la probabilidad de una secuencia completa en un producto de condicionales:

$P(x_1, x_2, \ldots, x_n) = \prod_{i=1}^{n} P(x_i \mid x_1, \ldots, x_{i-1})$

Es decir: en lugar de modelar la probabilidad de un texto entero, modelas la probabilidad del siguiente token dado todo lo anterior. Ese es exactamente el truco de los LLMs. Cada paso de generación es un problema de clasificación gigante: dadas las ~100K opciones del vocabulario, ¿cuál viene ahora?

La arquitectura que ejecuta esto es el Transformer en su variante decoder-only, con tres piezas clave por capa:

1. Self-attention con máscara causal: cada token calcula su relevancia respecto a todos los anteriores (nunca los futuros — eso sería hacer trampa durante el entrenamiento). Es el mecanismo que captura dependencias de largo alcance: el sujeto al inicio del párrafo, la variable declarada 200 líneas atrás.
2. Feed-forward (MLP): donde, según la evidencia de interpretabilidad, vive buena parte del “conocimiento” factual del modelo.
3. Capa final + softmax: convierte el estado interno en una distribución de probabilidad sobre el vocabulario completo.

Lo importante: la salida del modelo no es un token, es una distribución. El vector de salida (los logits) asigna un puntaje a cada token posible. Qué hacemos con esa distribución es una decisión separada — y ahí entra el muestreo.

Muestreo: por qué el mismo prompt da respuestas distintas

Tienes la distribución $P(x_i \mid \text{contexto})$. Opciones para elegir el token:

• Greedy decoding: tomar siempre el más probable. Determinista, pero produce texto repetitivo y plano — y un máximo local por token no garantiza la mejor secuencia global.
• Temperatura ($T$): reescala los logits antes del softmax: $P_i \propto e^{z_i / T}$. Con $T \to 0$ te acercas a greedy; con $T = 1$ muestreas la distribución tal cual; con $T > 1$ la aplanas y el modelo “se suelta” (y desvaría más).
• Top-k: muestrea solo entre los $k$ tokens más probables, descartando la cola.
• Top-p (nucleus sampling): muestrea del conjunto mínimo de tokens cuya probabilidad acumulada supera $p$ (p. ej. 0.9). Se adapta a la forma de la distribución: cuando el modelo está seguro, el núcleo es pequeño; cuando duda, se amplía. Propuesto en Holtzman et al. (2019).

En código, la diferencia entre greedy y temperatura es mínima — y explica por qué la IA generativa es estocástica por diseño:

import numpy as np

def sample_token(logits, temperature=0.7):
    if temperature == 0:
        return int(np.argmax(logits))      # greedy: determinista
    z = logits / temperature
    probs = np.exp(z - z.max())
    probs /= probs.sum()                   # softmax
    return int(np.random.default_rng().choice(len(probs), p=probs))

Regla práctica: temperatura baja (0–0.3) para extracción de datos, código y tareas con respuesta correcta; media (0.7–1.0) para escritura y brainstorming. Y nunca asumas determinismo en producción: incluso con $T=0$, la aritmética en paralelo sobre GPU puede introducir variaciones.

Estrategia 2: difusión (las imágenes, el audio, el video)

Para imágenes, la factorización token a token no es natural (¿en qué orden “lees” los píxeles?). La familia que domina la generación visual son los modelos de difusión (Ho et al., 2020), con una idea casi poética:

1. Proceso hacia adelante (fijo): toma una imagen real y agrégale ruido gaussiano en pasos sucesivos hasta que sea estática pura. Esto no se aprende; es un proceso matemático definido.
2. Proceso inverso (aprendido): entrena una red para predecir el ruido que se añadió en cada paso. Si sabes qué ruido se añadió, puedes quitarlo.
3. Generación: parte de ruido aleatorio puro y aplica la red iterativamente (decenas de pasos), “desruidando” hasta que emerge una imagen coherente.

El modelo nunca aprende a “dibujar”; aprende el gradiente que apunta desde el ruido hacia la variedad (manifold) de imágenes naturales. El condicionamiento por texto (“un astronauta a caballo”) se inyecta en cada paso de desruidado, típicamente vía cross-attention sobre los embeddings del prompt — así funciona Stable Diffusion, que además opera en un espacio latente comprimido para abaratar el cómputo.

Dos contrastes técnicos útiles frente a los LLMs:

• Autoregresivo: una pasada por token, el costo crece con la longitud de la salida. Difusión: decenas de pasadas por la red completa, pero genera toda la imagen “a la vez”.
• Las GANs (Goodfellow et al., 2014) — el enfoque dominante anterior, con un generador y un discriminador compitiendo — perdieron terreno frente a la difusión por su inestabilidad de entrenamiento y el mode collapse (el generador encuentra unos pocos ejemplos que engañan al discriminador y deja de explorar).

El pipeline de entrenamiento: tres etapas

Un modelo generativo de texto moderno no sale de una sola pasada de entrenamiento. El pipeline estándar:

1. Pre-entrenamiento

Predicción del siguiente token sobre billones de tokens de texto. Aquí se consume el ~99% del cómputo y se forma casi todo lo que el modelo “sabe”: gramática, hechos, patrones de razonamiento, código. La función de pérdida es entropía cruzada pura; el algoritmo, backpropagation sobre miles de GPUs durante meses, con los datos repartidos vía paralelismo de datos, de tensores y de pipeline.

El resultado es un modelo base: una máquina de autocompletar formidable que no es un asistente. Si le preguntas “¿cómo hago pan?”, es igual de probable que te responda con la receta o con otra pregunta — porque en internet las preguntas suelen aparecer en listas de preguntas.

2. Fine-tuning supervisado (SFT)

Se reentrena el modelo base con un dataset curado de conversaciones de alta calidad (instrucción → respuesta deseada). Mismo algoritmo, datos muchísimo más pequeños y selectos. Aquí el modelo aprende el formato de ser asistente: responder a lo que se pregunta, estructurar, admitir cuando no sabe.

3. Aprendizaje por refuerzo con retroalimentación

El SFT no basta para capturar preferencias matizadas (“esta respuesta es más útil/honesta/inofensiva que aquella”). Entra el RLHF (Ouyang et al., 2022): humanos comparan pares de respuestas, con esas comparaciones se entrena un reward model, y el LLM se optimiza contra esa recompensa. Anthropic añade Constitutional AI: el propio modelo critica y revisa sus respuestas según principios explícitos, reduciendo la dependencia de etiquetado humano para la parte de inocuidad.

Una consecuencia técnica que conviene tener presente: estas etapas de alineamiento modifican la distribución que el modelo muestrea. El modelo alineado ya no es un espejo estadístico de internet; es esa distribución sesgada deliberadamente hacia respuestas útiles y seguras.

Inferencia: lo que pasa cuando pulsas Enter

La generación tiene dos fases con perfiles de hardware opuestos:

1. Prefill: el prompt completo se procesa en paralelo en una sola pasada. Es intensivo en cómputo (las GPUs brillan aquí) y de ahí sale el time to first token.
2. Decode: los tokens de salida se generan uno a uno — cada token requiere una pasada completa por la red y depende del anterior. Esta fase está limitada por ancho de banda de memoria, no por cómputo: el cuello de botella es mover los cientos de GB de pesos desde la VRAM en cada paso.

Tres optimizaciones sostienen que esto sea económicamente viable:

• KV cache: en cada paso de atención, los vectores key y value de los tokens anteriores no cambian. Se cachean en memoria y solo se calcula lo del token nuevo, convirtiendo un costo cuadrático por token en lineal. Es también la razón técnica de que exista el prompt caching en las APIs: si el inicio del prompt es idéntico entre llamadas, su KV cache se reutiliza y pagas una fracción del precio.
• Cuantización: los pesos se entrenan en 16 bits pero pueden servirse en 8 o 4 bits con pérdida de calidad pequeña, reduciendo memoria y multiplicando el ancho de banda efectivo.
• Batching continuo: la GPU procesa decenas de conversaciones entrelazadas en el mismo lote, incorporando y retirando secuencias en caliente para no desperdiciar ciclos.

Entender el prefill/decode también explica el pricing de las APIs: los tokens de entrada son más baratos que los de salida porque el prefill es paralelo y el decode es secuencial.

Las fronteras técnicas abiertas

Para cerrar, el estado honesto de los problemas no resueltos:

• Alucinaciones: un muestreador de $P(x)$ produce lo plausible, no lo verdadero. Las mitigaciones (RAG, tool use, citas verificables, entrenamiento para abstenerse) reducen la tasa, pero la propiedad es inherente al paradigma generativo.
• Contexto largo: la atención es $O(n^2)$ en la longitud de secuencia. Las ventanas de cientos de miles de tokens existen gracias a variantes eficientes de atención y a ingeniería de memoria agresiva, pero “cabe en el contexto” no implica “se usa bien”: la recuperación de información degrada en posiciones intermedias.
• Razonamiento en inferencia: la frontera reciente no es solo escalar el entrenamiento sino escalar el cómputo en inferencia — modelos que generan cadenas de razonamiento internas antes de responder, gastando más tokens para pensar en problemas difíciles. Es, en esencia, mover parte del trabajo del entrenamiento al momento de la pregunta.
• Evaluación: medir calidad generativa sigue siendo un problema abierto. Los benchmarks se saturan y contaminan, y la evaluación con LLMs como jueces introduce sus propios sesgos.

Conclusión

La próxima vez que veas “IA generativa”, tradúcelo mentalmente: un modelo que aprendió una distribución de probabilidad y un sistema de ingeniería para muestrear de ella a escala. De esa traducción salen todas las intuiciones prácticas:

• Es estocástica porque muestrea — la temperatura y el top-p son perillas sobre esa distribución, no magia.
• Alucina porque optimiza plausibilidad, no verdad — verifica o dale herramientas para verificar.
• Cuesta lo que cuesta porque el decode es secuencial y limitado por memoria — de ahí el prompt caching, la cuantización y el precio asimétrico de los tokens.
• Se comporta como asistente porque su distribución fue deliberadamente sesgada con SFT y RLHF — no porque “entienda” lo que es ser útil.

No hay magia: hay probabilidad, una arquitectura que la factoriza y una cantidad heroica de ingeniería de sistemas. Y como ingenieros, ese es exactamente el tipo de magia con el que sabemos trabajar.

---

Referencias

Papers fundacionales

• Vaswani, A. et al. (2017). Attention Is All You Need. arXiv:1706.03762.
• Goodfellow, I. et al. (2014). Generative Adversarial Networks. arXiv:1406.2661.
• Ho, J., Jain, A., Abbeel, P. (2020). Denoising Diffusion Probabilistic Models. arXiv:2006.11239.
• Rombach, R. et al. (2022). High-Resolution Image Synthesis with Latent Diffusion Models (Stable Diffusion). arXiv:2112.10752.
• Holtzman, A. et al. (2019). The Curious Case of Neural Text Degeneration (nucleus sampling). arXiv:1904.09751.
• Ouyang, L. et al. (2022). Training language models to follow instructions with human feedback (RLHF/InstructGPT). arXiv:2203.02155.
• Bai, Y. et al. (2022). Constitutional AI: Harmlessness from AI Feedback. arXiv:2212.08073.

Material técnico para profundizar

• Karpathy, A. Let’s build GPT: from scratch, in code (implementa un transformer generativo completo).
• Lilian Weng. What are Diffusion Models? (la mejor derivación matemática accesible de difusión).
• Anthropic. Claude Developer Platform — Documentación (parámetros de muestreo, prompt caching, tool use).
• Kwon, W. et al. (2023). Efficient Memory Management for LLM Serving with PagedAttention (vLLM — la ingeniería detrás del serving moderno).

En este blog

• De la neurona al LLM: fundamentos de IA y machine learning — la base sobre la que construye este artículo.

---

#Inteligencia Artificial, #IA Generativa, #LLM, #Transformers, #Difusión, #Deep Learning,