KV Cache
Uma cache KV armazena as chaves e os valores dos tokens anteriores para que um Transformer não tenha de os recalcular, acelerando a geração de LLMs. Como funciona e quanto custa em memória.
Um cache KV (cache de chave-valor) armazena os vetores de chave e valor que as camadas de atenção de um transformer já calcularam para tokens anteriores, evitando que sejam recalculados quando o modelo gera o próximo token. Modelos de linguagem grandes (LLMs) produzem texto um token de cada vez, e cada novo token precisa prestar atenção a todos os tokens anteriores. Com um cache KV, cada etapa de geração calcula chaves e valores apenas para o token mais recente e lê os demais da memória, o que torna viáveis respostas longas. O custo é a memória: o cache cresce a cada token e, muitas vezes, ocupa mais memória da GPU do que os pesos do modelo em contextos longos ou na serving com lotes grandes.
Como funciona o cache KV#
Em cada camada de atenção, cada token é projetado em uma consulta, uma chave e um valor. A consulta de um token é comparada com as chaves de todos os tokens que ele pode ver, e os pesos resultantes combinam seus valores na saída. Em um LLM somente decodificador, um token só pode ver a si mesmo e os tokens anteriores, portanto, as chaves e os valores dos tokens passados não mudam depois de calculados. Assim, a geração ocorre em duas fases. Na fase de pré-preenchimento, o modelo processa todo o prompt em paralelo e preenche o cache. Na fase de decodificação, gera um token por etapa, adicionando a chave e o valor desse token ao cache, até emitir um token de fim de sequência ou atingir um limite de comprimento:
O pré-preenchimento é limitado pela capacidade de processamento, pois executa grandes multiplicações de matrizes sobre muitos tokens de uma só vez. A decodificação é limitada pela largura de banda da memória, pois cada etapa lê todo o cache e todos os pesos do modelo para produzir um único token.
Por que acelera a geração#
Sem cache, a etapa t recalcularia as chaves e os valores de todos os t tokens gerados até então, de modo que o trabalho total cresce quadraticamente com o comprimento da saída. Com o cache, cada etapa adiciona uma chave e um valor por camada. O exemplo de uma única cabeça abaixo decodifica uma sequência de 10 tokens com um cache e compara a saída final com um 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))}")Ele imprime Same output: True e cached 10, recomputed 55: o cache produz um resultado idêntico, projetando cada token uma única vez, em vez de 1 + 2 + ... + 10 projeções se cada etapa recomeçasse do zero.
Cache KV e conceitos relacionados#
- Cache de prompt: mantém o cache KV de um prefixo de prompt compartilhado, como um prompt de sistema longo ou um documento, e o reutiliza em solicitações separadas, de modo que as solicitações posteriores não precisam pré-preencher essa parte.
- Pesos do modelo: parâmetros fixos aprendidos durante o treinamento e compartilhados por todas as solicitações. Um cache KV pertence a uma sequência e é descartado quando ela termina.
- Incorporações: vetores que representam cada token quando ele entra no modelo. Cada camada deriva suas próprias chaves e valores do estado oculto do token, portanto, o cache armazena uma chave e um valor por token e por camada.
- Cache semântico: armazena respostas completas e as devolve para consultas posteriores semelhantes, sem executar o modelo.
Cache KV em modelos de visão#
Modelos de linguagem e visão (VLMs) transformam uma imagem em centenas ou milhares de tokens visuais, que entram no cache KV como texto; por isso, uma única imagem de alta resolução pode ocupar tanto cache quanto várias páginas de texto. Modelos de vídeo em streaming enfrentam o mesmo crescimento a cada quadro. O SAM 2, da Meta, que funciona no pacote Python da Ultralytics, aplica um cache semelhante à segmentação de vídeo: seu banco de memória armazena características codificadas de quadros anteriores, e a atenção à memória as consulta à medida que cada novo quadro é segmentado, mantendo o rastreamento dos objetos durante oclusões sem reprocessar quadros anteriores.
Custo de memória e como reduzi-lo#
O cache armazena dois vetores — uma chave e um valor — por token, para cada camada e cabeça de chave-valor; portanto, seu tamanho é 2 × camadas × cabeças KV × dimensão da cabeça × bytes por valor × tokens. Para o Llama 2 7B em FP16, com 32 camadas, 32 cabeças e dimensão de cabeça 128, isso corresponde a 512 KiB por token, ou 2 GiB para uma sequência de 4.096 tokens. Os sistemas de serving usam várias técnicas para acomodar mais sequências na memória:
- Atenção de consultas agrupadas (GQA): várias cabeças de consulta compartilham uma cabeça de chave-valor. O Llama 3 8B usa 8 cabeças KV para 32 cabeças de consulta, reduzindo o cache para 128 KiB por token.
- PagedAttention: armazena o cache em blocos de tamanho fixo, como páginas de memória virtual, alocando memória à medida que as sequências crescem. Introduzido com o mecanismo de serving vLLM, aumentou a taxa de transferência de 2 a 4 vezes em relação aos sistemas anteriores.
- Quantização do cache KV: armazena chaves e valores em FP8 ou INT8 em vez de FP16, reduzindo o cache pela metade.
- Atenção com janela deslizante: cada camada presta atenção apenas aos tokens mais recentes, limitando o cache ao tamanho da janela.
- Atenção latente multi-head (MLA): comprime chaves e valores em um pequeno vetor latente compartilhado antes de armazená-los em cache. No DeepSeek-V2, reduziu o cache KV em 93,3% em comparação com o modelo DeepSeek 67B anterior.










