Prompt Caching

A colocação em cache de instruções, também chamada colocação em cache de prefixos, armazena os resultados intermédios calculados por um modelo de linguagem de grande escala (LLM) para o início de uma instrução e reutiliza-os em pedidos posteriores que começam exatamente com o mesmo texto. Muitos pedidos partilham um prefixo longo e estável — como uma instrução de sistema, definições de ferramentas, um conjunto de exemplos, um documento extenso ou o histórico da conversa até ao momento — ao qual se segue uma parte nova e curta. Quando há uma ocorrência na cache, o servidor processa apenas os novos tokens, o que reduz o tempo até ao primeiro token de saída e, nas APIs alojadas, baixa o preço da entrada em cache para uma fração do preço normal.

Como funciona a colocação em cache de instruções#

Um LLM transformador responde em duas fases. Na fase de pré-preenchimento, cada camada calcula um vetor de chave e um vetor de valor para cada token da instrução; durante a descodificação, cada novo token presta atenção a todas essas chaves e valores através do mecanismo de atenção. Dentro de um pedido, a cache KV mantém esses tensores para que cada token gerado não tenha de recalcular a instrução. A colocação em cache de instruções mantém-nos entre pedidos. Como a atenção nestes modelos é causal, as chaves e os valores de um token dependem apenas dos tokens anteriores; assim, duas instruções com o mesmo prefixo têm chaves e valores idênticos para esse prefixo, e a cópia armazenada pode substituir o novo cálculo.

O exemplo seguinte mostra a reutilização com o GPT-2 dos Transformers da Hugging Face. Pré-preenche uma instrução de sistema com 409 tokens uma única vez e, em seguida, responde a duas perguntas executando apenas os respetivos tokens sobre o prefixo em cache; depois, compara o resultado com um novo cálculo completo:

import copy

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("gpt2")
model = AutoModelForCausalLM.from_pretrained("gpt2")

# A long system prompt shared by every request, followed by different user questions
system = "You answer questions about a camera store. " + "Returns are accepted within 30 days with a receipt. " * 40
questions = [" Question: Can I return a lens?", " Question: Do you ship abroad?"]
prefix_ids = tokenizer(system, return_tensors="pt").input_ids

with torch.no_grad():
    # Prefill the shared prefix once and keep its key-value cache
    prefix_cache = model(prefix_ids).past_key_values
    for question in questions:
        ids = tokenizer(question, return_tensors="pt").input_ids
        # Cache hit: only the question's tokens run through the model
        cached = model(ids, past_key_values=copy.deepcopy(prefix_cache)).logits[0, -1]
        # No cache: the whole prompt is computed from scratch
        full = model(torch.cat([prefix_ids, ids], dim=1)).logits[0, -1]
        same = torch.allclose(cached, full, atol=1e-3)
        print(f"Computed {ids.shape[1]} of {prefix_ids.shape[1] + ids.shape[1]} tokens, same next-token scores: {same}")

Apresenta Computed 8 of 417 tokens, same next-token scores: True e Computed 7 of 416 tokens, same next-token scores: True: cada pedido processou com o modelo menos de 2% dos tokens da instrução e obteve as mesmas pontuações para o token seguinte que o cálculo completo.

Os motores de serviço de modelos de código aberto aplicam este processo automaticamente. O vLLM mantém a cache KV em blocos de tamanho fixo, o esquema de memória da PagedAttention, reutiliza os blocos do prefixo correspondente mais longo para cada novo pedido e remove os blocos menos usados recentemente quando a memória da GPU começa a escassear. A RadixAttention do SGLang mantém os prefixos em cache numa árvore radix, para que os pedidos que partilham qualquer segmento inicial o reutilizem; o artigo sobre o SGLang indica um débito até 6,4 vezes superior ao de outros motores de inferência de última geração. O artigo sobre a Prompt Cache, de In Gim e colegas, apresentado na MLSys 2024, alarga a reutilização para além dos prefixos exatos, abrangendo módulos de instruções declarados, como modelos e documentos, e relata reduções do tempo até ao primeiro token entre 8 vezes na GPU e 60 vezes no CPU.

Colocação em cache de instruções nas APIs de LLM#

As APIs alojadas disponibilizam o mesmo mecanismo mediante um custo. A colocação em cache de instruções da OpenAI está ativada por predefinição nos modelos compatíveis, enquanto a colocação em cache de instruções do Claude da Anthropic é ativada com um campo cache_control, uma vez por pedido ou em até quatro blocos de conteúdo. A Anthropic cobra por uma leitura da cache um décimo ou menos do preço base da entrada e, por uma escrita na cache predefinida de cinco minutos, 1,25 vezes o preço base; cada ocorrência reinicia o prazo de cinco minutos. Ambos os fornecedores só identificam prefixos idênticos: a Anthropic compara as ferramentas, depois a instrução de sistema e, por fim, as mensagens; assim, editar a definição de uma ferramenta invalida tudo o que foi colocado em cache depois dela. O guia da OpenAI recomenda colocar primeiro as instruções estáveis e o material de referência, e deixar os detalhes específicos do utilizador para o fim.

As cargas de trabalho com prefixos longos partilhados são as que mais beneficiam:

• Agentes de IA: Em cada etapa, reenviam as definições das ferramentas e todo o histórico, que inclui a instrução da etapa anterior, mais a ação mais recente e o respetivo resultado.
• Chatbots: Cada turno de uma conversa amplia o prompt do turno anterior, por isso o histórico fica em cache até à nova mensagem.
• Perguntas e respostas sobre documentos: Muitas perguntas sobre um único contrato longo, relatório ou repositório reutilizam o documento processado, e os pipelines de recuperação reutilizam-no sempre que os mesmos trechos são recuperados novamente.
• Prompts few-shot: Dezenas de exemplos fixos são calculados uma vez e reutilizados para cada entrada.

Os modelos de visão de vocabulário aberto reutilizam o cálculo do prompt de forma semelhante. Ultralytics YOLOE codifica prompts de classe como "empilhadora" com um codificador de texto MobileCLIP uma vez, quando set_classes() é chamado, e armazena os embeddings resultantes no modelo, para que as previsões seguintes ignorem totalmente o codificador de texto; save_prompt_embeddings() grava-os num ficheiro NPZ que uma sessão posterior carrega com load_prompt_embeddings() em vez de executar novamente o codificador.

Cache de prompts vs. termos relacionados#

• Cache KV: Reutiliza chaves e valores entre os tokens de uma única geração. O cache de prompts reutiliza-os entre pedidos separados.
• Cache semântico: Armazena respostas completas e devolve uma delas quando uma nova consulta significa o mesmo que uma anterior, ignorando totalmente o modelo. O cache de prompts continua a executar o modelo na parte nova do prompt e gera uma resposta nova.
• Compressão de prompts: Encurta o próprio prompt, o que é adequado para texto que muda a cada pedido. As duas técnicas combinam bem: a parte fixa do prompt fica em cache e a parte variável é comprimida.
• Engenharia de prompts: Determina o que o prompt diz. O cache altera apenas a quantidade que o servidor recalcula, e um acerto mantém inalteradas as pontuações dos tokens seguintes, salvo diferenças de arredondamento de vírgula flutuante.