El modelo cabe en memoria, pero cuatro conversaciones no
Un asistente empresarial responde bien a una pregunta breve. Después cuatro personas envían documentos largos y la memoria se agota antes de terminar las respuestas. El archivo del modelo no cambió. ¿Qué crece? Una parte importante es la memoria del contexto: durante la generación conserva representaciones del texto procesado para reutilizarlas. Queremos entender su coste y por qué importa tanto el número de conversaciones como su longitud.
Resumen. Deducimos el coste de la caché clave-valor de un decodificador causal con atención densa a partir de las dimensiones de los datos. Un ejemplo sintético de 32 capas y ocho cabezas KV necesita 4 GiB para cuatro secuencias de 8.192 tokens. Comparamos cabezas compartidas, prefijos comunes, cuantización y un presupuesto con pesos y espacio de trabajo. Son conteos, no medidas de memoria asignada ni latencia. Explican el límite sin certificar que una GPU o un entorno concreto ejecute la carga.
Qué se conserva y por qué
Un modelo autorregresivo genera un token cada vez usando el contexto previo. En atención, el token actual produce una query, representación para compararse con el pasado. Los tokens procesados aportan keys, claves para esa comparación, y values, valores que combinar. No son frases copiadas en una agenda, sino vectores numéricos internos. Distintas cabezas realizan comparaciones paralelas con representaciones diferentes.
En este decodificador causal, los tokens anteriores no ven los futuros. Con modelo y convenciones de posición fijos, sus claves y valores se reutilizan después. La caché KV los conserva en cada capa. Evita recalcularlos, pero no elimina comparar la nueva query con el pasado. El texto leído sigue costando: parte del cálculo ahorrado se sustituye por almacenamiento.
Contar números antes de contar gigabytes
Definimos L como capas con caché, B como secuencias simultáneas, T como tokens conservados por secuencia, H_KV como cabezas de claves y valores, d como dimensión de cada cabeza y s como bytes por número. Suponemos igual longitud y configuración en todas las capas, sin compartir prefijos ni comprimir. K contiene B×T×H_KV×d elementos por capa y V otros tantos.
El factor 2 cuenta K y V; L repite el conteo por capa. Los demás factores describen dimensiones del tensor. Es memoria de datos de caché, no del proceso completo. Excluye pesos, activaciones temporales, logits del vocabulario, metadatos del gestor y reservas del entorno. Una fórmula útil debe decir también qué omite.
El caso numérico: cuatro documentos de 8.192 tokens
Elegimos L=32, B=4, T=8.192, H_KV=8, d=128 y s=2 bytes por elemento. Son parámetros ilustrativos, no especificaciones de un modelo concreto. Obtenemos 4.294.967.296 bytes, exactamente 4 GiB. Un GiB son 2³⁰ bytes, distinto del GB decimal de mil millones. Para una sola secuencia el resultado es 1 GiB.
Cada token adicional cuesta 2×32×8×128×2=131.072 bytes por secuencia, 128 KiB. Si las cuatro conversaciones crecen un token, aumentan 512 KiB. T incluye lo conservado por el entorno: prompt y tokens generados aún retenidos, no solo la entrada inicial. Presupuestar únicamente la pregunta puede dejar de ser suficiente durante una respuesta larga.
| Secuencias B | Tokens T | Cabezas KV | Caché GiB |
|---|---|---|---|
| 1 | 8192 | 8 | 1 |
| 4 | 8192 | 8 | 4 |
| 4 | 8192 | 32 | 16 |
| 4 | 16384 | 8 | 8 |
Por qué importan las cabezas KV y no solo las queries
No toda cabeza query necesita claves y valores separados. En la atención multicabeza clásica, MHA, los conteos coinciden. En grouped-query attention, GQA, varias queries comparten una cabeza KV. Conservamos 32 queries y reducimos KV de 32 a 8: la caché pasa de 16 a 4 GiB por almacenar menos vectores distintos. No significa poder borrar tres cuartas partes de los tensores de cualquier modelo sin alterar su comportamiento.
Ainslie y colaboradores publicaron GQA en EMNLP 2023. Leímos métodos, experimentos y límites de arXiv v3, del 23 de diciembre de 2023: T5 codificador-decodificador, tiempos en TPUv4 y adaptación tras convertir. No trasladamos resultados a GPU ni a modelos solo decodificadores, ni presentamos GQA como novedad de 2026; calculamos memoria.
La pendiente indica cuánto cuesta ampliar el contexto. Duplicar T duplica esta memoria; duplicar B también. No representamos la matriz T×T de puntuaciones de atención. Evitar materializarla y conservar KV son problemas diferentes: atención eficiente no convierte en gratuito el historial almacenado.
Un presupuesto completo cambia cuántas solicitudes caben
Añadamos un modelo hipotético de seis mil millones de parámetros a dos bytes: solo los pesos ocupan doce mil millones de bytes, unos 11,1759 GiB. Supongamos además 2 GiB reservados para el resto y 16 GiB disponibles. Son cifras elegidas, no medidas. Cuatro secuencias suman 11,1759+2+4≈17,1759 GiB: no caben. Tres suman 16,1759, todavía demasiado; dos, 15,1759.
Que dos secuencias «quepan en el cálculo» no promete que funcionen. La reserva real depende del entorno, kernels, procesamiento del prompt, tensores intermedios, fragmentación y otras asignaciones. El conteo orienta la planificación y debe compararse con el pico medido. No ejecutamos el modelo, elegimos GPU ni medimos picos; el JSON llama al resultado arithmeticFits, compatibilidad aritmética.
¿Siempre hacen falta cuatro copias del mismo prefijo?
Cuatro conversaciones pueden empezar con instrucciones y documento idénticos. Si el entorno permite compartir de forma segura un prefijo inmutable, lo contamos una vez y los sufijos por separado. Sea P=4.096 tokens comunes entre T=8.192 por secuencia. Sin compartir conservamos BT=32.768 posiciones; con compartición ideal:
El ahorro teórico es 1,5 GiB frente a 4. No basta ver el mismo texto: deben coincidir tokens, pesos y adaptadores, posiciones y condiciones de atención. Cambiar instrucciones anteriores puede modificar representaciones posteriores. Los sufijos deben separarse cuando divergen las respuestas. No implementamos ese entorno; calculamos el beneficio ideal del supuesto, antes de metadatos y bloques de asignación.
Cuantizar la caché no reduce toda la memoria a la mitad
Cada número KV ocupa inicialmente dos bytes. Una representación de ocho bits reduce solo los datos de 4 a 2 GiB. La cuantización puede necesitar escalas y metadatos. Nuestro esquema contable añade una escala de dos bytes cada 64 valores, sin punto cero: 2/64 bytes extra por valor. El total es 2×(1+2/64)=2,0625 GiB, no exactamente 2.
Es una fórmula de espacio, no un algoritmo de cuantización evaluado. No cuantizamos tensores reales, medimos errores de respuesta ni demostramos aceleración. Copias temporales descuantizadas pueden afectar al pico. Reducir KV deja intactos pesos y reserva, por lo que el ahorro porcentual total es menor. El método concreto requiere validación numérica y aplicada.
Qué cambia en el entorno y qué no se deduce del conteo
Hugging Face documenta cachés dinámicas, estáticas y deslizantes, máscaras y un ciclo de generación, que leímos. Las dinámicas crecen, las estáticas pueden reservar capacidad antes y las ventanas limitan el historial. No ejecutamos esos componentes. T debe reflejar la longitud asignada y las capas implicadas.
Una ventana menor no comprime gratis la misma información: elimina acceso directo a tokens anteriores según arquitectura y política. Mover la caché fuera del acelerador cambia su ubicación, no su volumen, y puede añadir transferencias. Cuatro veces menos KV tampoco garantiza cuatro veces menos latencia: proyecciones, atención, ancho de banda, sincronización e implementación influyen en el tiempo.
La respuesta y el protocolo necesario para medir
El texto leído ocupa memoria porque el modelo conserva representaciones útiles para tokens siguientes, por capa y secuencia. El ejemplo llega a 4 GiB sin pesos; con el resto, cuatro solicitudes superan el presupuesto hipotético de 16 GiB. Hay que dimensionar longitud, concurrencia y representación conjuntamente, no solo el modelo descargado. Es una consideración de diseño, no un informe medido de infraestructura EL-AI.
Una prueba real fijaría checkpoint, tokenizador, precisiones de pesos y KV, GPU, versión del entorno, backend de atención, solicitudes, longitudes y asignación. Mediría por separado memoria asignada y reservada, picos de prompt y generación, latencia y rendimiento. El protocolo está propuesto, no ejecutado. El paquete contiene conteos enteros deterministas, sin semilla, aserciones y datos gráficos: O(1) operaciones aritméticas por configuración, sin simular tensores.
Fuentes primarias y código
Hugging Face Transformers — How caching works.
Ainslie, Lee-Thorp, de Jong, Zemlyanskiy, Lebrón, Sanghai — GQA, arXiv v3, 23 December 2023.
GQA — EMNLP 2023, ACL Anthology.
GiB = 2**30
layers, kv_heads, head_dim, bytes_per_value = 32, 8, 128, 2
def cache_bytes(batch, tokens):
return 2 * layers * batch * tokens * kv_heads * head_dim * bytes_per_value
for batch in (1, 2, 3, 4):
kv = cache_bytes(batch, 8192)
total = 6_000_000_000 * 2 + 2 * GiB + kv
print(batch, kv/GiB, total/GiB, total <= 16*GiB)
Código, datos e instrucciones · JSON. Cálculos didácticos ejecutados con Python 3.14.0; figuras con Matplotlib 3.11.2. Análisis asistido por IA, sin afirmar revisión por pares ni humana. Portada original ImageGen ilustrativa: no documenta personas, sedes ni instalaciones de EL-AI. Fuentes consultadas el 3 de octubre de 2026.