Orçamento de memória do cache KV
A missão
Problema
Enquanto um transformer gera texto, ele guarda um vetor de chave e um vetor de valor para cada token anterior, em cada camada e em cada head de chave-valor, para que cada novo token não precise recalculá-los. Dados o número de camadas, o número de heads de chave-valor, o tamanho de cada head, o número de tokens em cache, o batch size e os bytes por número armazenado, retorne a memória de que o cache precisa em MiB (2^20 bytes). A capacidade de serviço é planejada exatamente a partir desse número, já que ele cresce a cada token de cada conversa do batch.
Exemplos
Input: layers = 32, kv_heads = 32, head_dim = 128, tokens = 4096, batch = 1, 2 bytes per number
Output: 2048.0
Por quê: 512 KiB por token, vezes 4.096 tokens
Input: layers = 32, kv_heads = 8, head_dim = 128, tokens = 4096, batch = 1, 2 bytes per number
Output: 512.0
Por quê: compartilhar cada head de chave-valor entre 4 heads de consulta divide o cache por 4
Input: layers = 32, kv_heads = 8, head_dim = 128, tokens = 0
Output: 0.0
Por quê: edge case: um prompt vazio ainda não tem nada em cache
Dicas
0 / 3
Calcule primeiro o custo de um único token e depois escale. Tudo no cache é proporcional ao número de tokens e ao batch size.
Para um token, cada camada guarda kv_heads × head_dim números para a chave e outros tantos para o valor.
Bytes = 2 × layers × kv_heads × head_dim × bytes_per_value × tokens × batch. Divida por 2 ** 20 para obter MiB.
- Tempo-alvo
- O(1)
- Espaço-alvo
- O(1)
Solução
Cada token em cache custa uma chave e um valor por camada e por head de chave-valor, cada um com head_dim números, então o custo por token é 2 × layers × kv_heads × head_dim × bytes, e o cache inteiro é isso vezes os tokens e o batch. A fórmula deixa à vista as alavancas de sempre: menos heads de chave-valor, como na grouped-query attention, reduzem o cache na mesma proporção; um formato numérico menor, como 8 bits, o divide de novo pela metade; e um batch maior ou um contexto mais longo o multiplicam. É por isso que contextos longos esbarram no limite de memória antes de esbarrar no limite de computação. O tempo e o espaço são O(1).
def kv_cache_mib(layers, kv_heads, head_dim, tokens, batch=1, bytes_per_value=2):
per_token = 2 * layers * kv_heads * head_dim * bytes_per_value # one key and one value
return per_token * tokens * batch / 2 ** 20
print(kv_cache_mib(32, 32, 128, 4096)) # -> 2048.0
print(kv_cache_mib(32, 8, 128, 4096)) # -> 512.0
print(kv_cache_mib(32, 8, 128, 0)) # -> 0.0
print(kv_cache_mib(32, 8, 128, 4096, batch=16, bytes_per_value=1)) # -> 4096.0Travou na ideia, e não no código? O cache KV explica isso.