KV Cache
Una caché KV almacena las claves y los valores de los tokens anteriores para que un Transformer no tenga que volver a calcularlos, lo que acelera la generación de LLM. Cómo funciona y cuánto espacio de memoria ocupa.
Una caché KV (caché de claves y valores) almacena los vectores de claves y valores que las capas de atención de un transformador ya han calculado para los tokens anteriores, de modo que no es necesario volver a calcularlos cuando el modelo genera el siguiente token. Los modelos de lenguaje de gran tamaño (LLMs) generan texto, un token cada vez, y cada token nuevo debe prestar atención a todos los tokens anteriores. Con una caché KV, en cada paso de generación solo se calculan las claves y los valores del token más reciente, mientras que el resto se lee de la memoria, lo que hace viables las respuestas largas. La contrapartida es el consumo de memoria: la caché crece con cada token y a menudo ocupa más memoria de GPU que los pesos del modelo en configuraciones de contexto largo o de servicio con lotes grandes.
Cómo funciona la caché KV#
En cada capa de atención, cada token se proyecta en una consulta, una clave y un valor. La consulta de un token se compara con las claves de todos los tokens a los que puede acceder, y los pesos resultantes combinan sus valores para generar la salida. En un LLM solo de decodificador, un token solo puede acceder a sí mismo y a los tokens anteriores, por lo que las claves y los valores de los tokens pasados no cambian una vez calculados. Por eso, la generación se ejecuta en dos fases. En la fase de prellenado, el modelo procesa toda la instrucción en paralelo y llena la caché. En la fase de decodificación, genera un token por paso y lo añade a la caché con su clave y su valor, hasta que emite un token de fin de secuencia o alcanza un límite de longitud:
El prellenado está limitado por la capacidad de cálculo, ya que ejecuta grandes multiplicaciones de matrices sobre muchos tokens a la vez. La decodificación está limitada por el ancho de banda de memoria, ya que en cada paso lee toda la caché y todos los pesos del modelo para producir un único token.
Por qué acelera la generación#
Sin caché, en el paso t se volverían a calcular las claves y los valores de los t tokens generados hasta entonces, por lo que el trabajo total crece cuadráticamente con la longitud de la salida. Con la caché, cada paso añade una clave y un valor por capa. El ejemplo de una sola cabeza que aparece a continuación decodifica una secuencia de 10 tokens con caché y compara la salida final con un recálculo completo:
import torch
torch.manual_seed(0)
d = 64
w_q, w_k, w_v = torch.randn(3, d, d) / d**0.5 # one attention head's projections
tokens = torch.randn(10, d) # embeddings of a 10-token sequence
# Decode token by token: project only the newest token and append it to the cache
k_cache, v_cache = torch.empty(0, d), torch.empty(0, d)
for x in tokens:
k_cache = torch.cat([k_cache, (x @ w_k)[None]])
v_cache = torch.cat([v_cache, (x @ w_v)[None]])
out_cached = torch.softmax((x @ w_q) @ k_cache.T / d**0.5, dim=-1) @ v_cache
# Without a cache, the last step re-projects keys and values for all 10 tokens
k_full, v_full = tokens @ w_k, tokens @ w_v
out_full = torch.softmax((tokens[-1] @ w_q) @ k_full.T / d**0.5, dim=-1) @ v_full
print(f"Same output: {torch.allclose(out_cached, out_full, atol=1e-5)}")
print(f"Key/value projections over 10 steps: cached {len(tokens)}, recomputed {sum(range(1, len(tokens) + 1))}")Imprime Same output: True y cached 10, recomputed 55: la caché produce un resultado idéntico y proyecta cada token una sola vez, frente a 1 + 2 + ... + 10 proyecciones si se volviera a empezar en cada paso.
Caché KV frente a conceptos relacionados#
- Almacenamiento en caché de instrucciones: conserva la caché KV de un prefijo de instrucción compartido, como una instrucción de sistema o un documento largos, y la reutiliza en distintas solicitudes, de modo que las solicitudes posteriores omiten esa parte del prellenado.
- Pesos del modelo: los parámetros fijos que se aprenden durante el entrenamiento y se comparten en todas las solicitudes. Una caché KV pertenece a una secuencia y se descarta cuando esta termina.
- Incrustaciones: los vectores que representan cada token cuando entra en el modelo. Cada capa obtiene sus propias claves y valores a partir del estado oculto del token, por lo que la caché contiene una clave y un valor por token y por capa.
- Almacenamiento en caché semántico: guarda respuestas completas y las devuelve para consultas posteriores similares, sin ejecutar el modelo.
Caché KV en modelos de visión#
Los modelos de visión y lenguaje (VLMs) convierten una imagen en cientos o miles de tokens visuales, y esos tokens se incorporan a la caché KV igual que el texto, por lo que una sola imagen de alta resolución puede ocupar tanto espacio en la caché como varias páginas de texto. Los modelos de vídeo en streaming experimentan el mismo crecimiento con cada fotograma. El SAM 2 de Meta, que se ejecuta en el paquete de Python de Ultralytics, emplea una caché similar para la segmentación de vídeo: su banco de memoria almacena características codificadas de fotogramas anteriores, y el mecanismo de atención a la memoria las consulta mientras se segmenta cada fotograma nuevo, manteniendo el seguimiento de los objetos incluso durante las oclusiones sin volver a procesar los fotogramas anteriores.
Coste de memoria y cómo reducirlo#
La caché contiene dos vectores —una clave y un valor— por token, capa y cabeza de clave-valor, por lo que su tamaño es 2 × capas × cabezas KV × dimensión de cabeza × bytes por valor × tokens. Para Llama 2 7B en FP16, con 32 capas, 32 cabezas y una dimensión de cabeza de 128, eso supone 512 KiB por token, o 2 GiB para una secuencia de 4096 tokens. Los sistemas de servicio emplean varias técnicas para almacenar más secuencias en memoria:
- Atención de consultas agrupadas (GQA): varias cabezas de consulta comparten una cabeza de clave-valor. Llama 3 8B utiliza 8 cabezas KV para 32 cabezas de consulta, lo que reduce la caché a 128 KiB por token.
- PagedAttention: almacena la caché en bloques de tamaño fijo, como las páginas de memoria virtual, de modo que la memoria se asigna a medida que crecen las secuencias. Se introdujo con el motor de servicio vLLM y aumentó el rendimiento entre 2 y 4 veces respecto a los sistemas anteriores.
- Cuantización de la caché KV: almacena las claves y los valores en FP8 o INT8 en lugar de FP16, lo que reduce la caché a la mitad.
- Atención de ventana deslizante: cada capa presta atención solo a los tokens más recientes, lo que limita la caché al tamaño de la ventana.
- Atención latente multi-cabeza (MLA): comprime las claves y los valores en un pequeño vector latente compartido antes de almacenarlos en caché. En DeepSeek-V2, redujo la caché KV un 93,3 % en comparación con el modelo anterior DeepSeek 67B.










