Inferencia: cómo responde un modelo

Dos fases, dos cuellos de botella

Un modelo denso con $N$ parámetros hace unas $2N$ operaciones por cada token que procesa (una multiplicación y una suma por parámetro; Kaplan et al., 2020; Pope et al., 2022), más un término de atención que crece con el contexto.

Llenado (los $L$ tokens del mensaje a la vez; $n_\ell$ bloques, $d_{\text{at}}$ = cabezas × dimensión por cabeza):

Son multiplicaciones de matrices grandes: la GPU trabaja cerca de su pico. La lección supone el 40 % del pico (Llama 3 reporta entre 38 y 43 % al entrenar; Pope et al. llegan a 76 % en el llenado con lotes grandes). Con el modelo de 8 mil M y 2 000 tokens: $3.3\cdot10^{13}$ FLOPs ÷ $(0.4\cdot 989\cdot10^{12})$ ≈ 84 ms.

Decodificación ($B$ conversaciones de $L$ tokens de contexto cada una). Cada vuelta tiene un tiempo de memoria y un tiempo de cálculo (Pope et al., §2), y manda el mayor:

con $W$ los bytes de los pesos, $c_{kv}$ los bytes de caché por token, BW el ancho de banda y $P$ el cálculo útil (la lección usa la mitad del pico). Con $B=1$ hay $2N$ operaciones por cada $W=bN$ bytes, es decir $2/b$ operaciones por byte: una, en FP16. La H100 puede hacer $989\cdot10^{12}/3.35\cdot10^{12}\approx 295$ por byte, así que la decodificación de una persona usa cerca del 0.3 % del cálculo. Pope et al. lo dicen así: con lotes y secuencias cortas domina el tiempo de cargar los pesos; con lotes grandes y secuencias largas, el de cargar la caché.

La caché KV por dentro

El 2 es clave y valor; $n_{kv}$ las cabezas de clave-valor; $d_h$ la dimensión por cabeza y $b$ los bytes por número. Llama 3 8B (Llama Team, 2024, tabla 3): $2\cdot32\cdot8\cdot128\cdot2=131\,072$ bytes por token (en la escena, $8\cdot128=1\,024$ números por clave y por bloque). Con atención multicabeza completa (32 cabezas KV) serían $524\,288$: Llama 3 usa atención de consultas agrupadas (GQA, Ainslie et al., 2023), que comparte cada par entre cuatro cabezas de consulta, «para reducir el tamaño de las cachés de clave-valor durante la decodificación». La misma cuenta da el valor de Kwon et al. (2023) para OPT-13B: $2\cdot5\,120\cdot40\cdot2=819\,200$ bytes, unos 800 KB por token.

Sin caché, generar $G$ tokens tras $P$ de entrada procesa $GP+G(G-1)/2$ posiciones; con caché, $P+G-1$. Con $P=6$ y $G=10$: $105$ frente a $15$. El transformer de juguete de la escena (2 bloques, 2 cabezas, $d=16$, pesos al azar con semilla fija; tiny.ts) recorre los dos caminos: cuenta 105 y 15 pasadas, 498 240 y 72 960 multiplicaciones-sumas, y sus logits coinciden con una diferencia máxima de 0.

Techo de velocidad, lotes y costo

Con el 8B en FP16 en una H100, 8 000 tokens de contexto y 2 USD por hora de GPU (supuesto): $B=1$ da 196 tokens/s y 2.84 USD por millón; $B=60$, el máximo que cabe, da 42 tokens/s por persona, 2 545 en total y 0.22 USD por millón: unas trece veces más barato en la misma máquina. Con 128 000 tokens de contexto solo caben 3 conversaciones.

Lo que paga quien usa una API

En las listas consultadas el 12 de octubre de 2026, la salida cuesta cinco veces la entrada en todos los modelos de Anthropic, y de cinco a más de ocho veces en los de Google. Los precios de la escena (US$ 3 y 15 por millón) son un ejemplo con esa proporción. Si el inicio de tu mensaje se repite (instrucciones, un documento base), la caché de prompt lo cobra mucho más barato: en la lista de Anthropic, leer de ella cuesta 0.1 veces el precio de entrada (0.05 o 0.025 en algunos modelos) y escribir en ella, con vigencia de cinco minutos, 1.25 veces.

Las esperas de la escena son estimaciones con el modelo de 8 mil M en una H100 y una sola persona: llenado al 40 % del pico, y cada vuelta de escritura con el tiempo de memoria de arriba.

Mezcla de expertos

Cada bloque reemplaza su red por $E$ expertos y un enrutador que elige $k$ por token:

Mixtral 8x7B (Jiang et al., 2024, tabla 1): $d=4\,096$, $h=14\,336$, $n_\ell=32$, $E=8$, $k=2$. Salen 46.7 mil millones en total y 12.9 activos. El artículo lo dice así: el cálculo es proporcional a los parámetros activos, pero «el costo de memoria para servir Mixtral es proporcional a su cantidad de parámetros dispersos, 47B». Si cada token eligiera sus dos expertos al azar (supuesto: en la práctica el reparto es desigual), un lote de $B$ tokens tocaría en cada bloque una fracción $1-(1-k/E)^B$ de los expertos: 25 % con $B=1$, 90 % con $B=8$, 99 % con $B=16$.

En código

Caché, techo de velocidad y costo con la arquitectura de Llama 3 8B:

capas, cabezas_kv, dim_cabeza, bytes_num = 32, 8, 128, 2
kv_por_token = 2 * capas * cabezas_kv * dim_cabeza * bytes_num      # 2 = clave y valor
print(kv_por_token)                                                  # bytes por token

pesos = 8.03e9 * 2                                                   # FP16: 2 bytes por parámetro
print(round(kv_por_token * 128_000 / 1e9, 2))                        # GB de una conversación de 128 000 tokens

ancho_banda = 3.35e12                                                # H100 SXM: 3.35 TB/s
print(round(ancho_banda / pesos, 1))                                 # techo de tokens/s con una persona

def servir(personas, contexto, usd_por_hora=2.0):
    bytes_por_vuelta = pesos + personas * contexto * kv_por_token    # pesos + una caché por persona
    t = bytes_por_vuelta / ancho_banda                               # segundos por vuelta
    rendimiento = personas / t                                       # tokens/s de todo el sistema
    return round(1 / t, 1), round(rendimiento), round(usd_por_hora / (3600 * rendimiento) * 1e6, 3)

print(servir(1, 8000))     # (tokens/s por persona, tokens/s totales, US$ por millón)
print(servir(60, 8000))
# 131072
# 16.78
# 208.6
# (195.8, 196, 2.837)
# (42.4, 2545, 0.218)

La caché no cambia el resultado: atención de una cabeza con y sin caché.

import numpy as np

rng = np.random.default_rng(0)
d = 8
Wq, Wk, Wv = (rng.normal(size=(d, d)) for _ in range(3))
x = rng.normal(size=(6, d))                          # 6 tokens (ya convertidos en vectores)

def atencion_sin_cache(x):                           # recalcula K y V de todos los tokens
    q, k, v = x @ Wq, x @ Wk, x @ Wv
    s = q @ k.T / np.sqrt(d)
    s = np.where(np.tril(np.ones_like(s)) == 1, s, -np.inf)       # máscara causal
    w = np.exp(s - s.max(1, keepdims=True)); w /= w.sum(1, keepdims=True)
    return w @ v

K, V, salida = [], [], []                            # con caché: un token por vuelta
for t in range(len(x)):
    q = x[t] @ Wq
    K.append(x[t] @ Wk); V.append(x[t] @ Wv)         # solo el par nuevo entra a la caché
    s = np.array(K) @ q / np.sqrt(d)
    w = np.exp(s - s.max()); w /= w.sum()
    salida.append(w @ np.array(V))

print(np.allclose(atencion_sin_cache(x), np.array(salida)))
# True

Lo que viene

Los sistemas reales añaden más piezas: PagedAttention reparte la caché en bloques para no desperdiciar memoria (vLLM: de 2 a 4 veces más rendimiento con la misma latencia que sistemas anteriores, Kwon et al., 2023); el batching continuo mete y saca conversaciones del lote en cada vuelta (Orca, Yu et al., 2022); y la decodificación especulativa dio de 2 a 3 veces más velocidad en T5-XXL «con salidas idénticas» (Leviathan et al., 2023) y de 2 a 2.5 veces en Chinchilla 70B (Chen et al., 2023). Todo esto sirve a un modelo base; convertirlo en asistente empieza con el ajuste fino, en la lección 27.