O Google Kubernetes Engine (GKE) oferece um controlo detalhado para a inferência de modelos de linguagem (conteúdo extenso) (MDL/CE) com desempenho e custo ideais. Este guia descreve as práticas recomendadas para otimizar a inferência e a publicação de LLMs abertos com GPUs no GKE através das estruturas de publicação vLLM e Text Generation Inference (TGI).
Para uma lista de verificação resumida de todas as práticas recomendadas, consulte o Resumo da lista de verificação.
Objetivos
Este guia destina-se a clientes de IA generativa, utilizadores novos ou existentes do GKE, engenheiros de ML e engenheiros de LLMOps (DevOps) que tenham interesse em otimizar as respetivas cargas de trabalho de LLM com GPUs e o Kubernetes.
No final deste guia, vai ser capaz de:
- Escolha técnicas de otimização de MDIs pós-preparação, incluindo quantização, paralelismo de tensores e otimização de memória.
- Pondere as compensações de alto nível quando considerar estas técnicas de otimização.
- Implemente modelos de LLM abertos no GKE através de frameworks de fornecimento, como o vLLM ou o TGI, com as definições de otimização ativadas.
Vista geral das técnicas de otimização da publicação de MDIs
Ao contrário das cargas de trabalho não relacionadas com IA, as cargas de trabalho de MDIs apresentam normalmente uma latência mais elevada e um débito inferior devido à sua dependência de operações de multiplicação de matrizes. Para melhorar o desempenho da inferência de MDIs, pode usar aceleradores de hardware especializados (por exemplo, GPUs e TPUs) e frameworks de publicação otimizados.
Pode aplicar uma ou mais das seguintes práticas recomendadas para reduzir a latência da carga de trabalho do MDG, ao mesmo tempo que melhora o débito e a rentabilidade:
Os exemplos neste guia usam o MDG Gemma 7B juntamente com as estruturas de publicação vLLM ou TGI para aplicar estas práticas recomendadas. No entanto, os conceitos e as funcionalidades descritos são aplicáveis à maioria dos MDGs abertos populares.
Antes de começar
Antes de experimentar os exemplos neste guia, conclua estas tarefas prévias:
Siga as instruções nestes guias para aceder ao modelo Gemma, preparar o seu ambiente e criar e configurar Trusted Cloud by S3NS recursos:
- Apresente modelos abertos Gemma com GPUs no GKE com o vLLM
- Apresente modelos abertos Gemma com GPUs no GKE com o TGI do Hugging Face
Certifique-se de que guarda o token de acesso da Hugging Face no seu segredo do Kubernetes.
Clone o repositório de exemplos https://github.com/GoogleCloudPlatform/kubernetes-engine-samples/ para o seu ambiente de desenvolvimento local.
Altere o diretório de trabalho para
/kubernetes-engine-samples/ai-ml/llm-serving-gemma/.
Prática recomendada: quantização
A quantização é uma técnica análoga à compressão de imagens com perdas que reduz o tamanho do modelo representando os pesos em formatos de menor precisão (8 bits ou 4 bits), reduzindo assim os requisitos de memória. No entanto, tal como a compressão de imagens, a quantização envolve uma compensação: a diminuição do tamanho do modelo pode levar a uma redução da precisão.
Existem vários métodos de quantização, cada um com as suas próprias vantagens e desvantagens únicas. Alguns, como o AWQ e o GPTQ, requerem pré-quantização e estão disponíveis em plataformas como o Hugging Face ou o Kaggle. Por exemplo, se aplicar a GPTQ no modelo Llama-2 13B e a AWQ no modelo Gemma 7B, pode publicar os modelos numa única GPU L4 em vez de duas GPUs L4 sem quantização.
Também pode realizar a quantização através de ferramentas como o AutoAWQ
e o AutoGPTQ. Estes métodos podem melhorar a latência e o débito. Por outro lado, as técnicas que usam a EETQ e a biblioteca
bitsandbytes
para a quantização não requerem modelos pré-quantizados, pelo que podem ser uma
escolha adequada quando as versões pré-quantizadas não estão disponíveis.
A melhor técnica de quantização a usar depende dos seus objetivos específicos e da compatibilidade da técnica com a framework de publicação que quer usar. Para saber mais, consulte o guia de quantização da Hugging Face.
Selecione um destes separadores para ver um exemplo de aplicação da quantização através das frameworks TGI ou vLLM:
TGI
O GKE suporta estas opções de quantização com o TGI:
awqgptqeetqbitsandbytesbitsandbytes-nf4bitsandbytes-fp4
Os métodos de quantização AWQ e GPTQ requerem modelos pré-quantizados, enquanto a quantização EETQ e bitsandbytes pode ser aplicada a qualquer modelo. Para saber mais
acerca destas opções, consulte este artigo da Hugging Face.
Para usar a quantização, defina o parâmetro -–quantize ao iniciar o servidor do modelo.
O fragmento seguinte mostra como otimizar o Gemma 7B com a quantização bitsandbytes através da TGI no GKE.
Para aplicar esta configuração, use o seguinte comando:
kubectl apply -f tgi/tgi-7b-bitsandbytes.yaml
vLLM
O GKE suporta estas opções de quantização com o vLLM:
gptq– com quantização de 4 bits (não suportada para o Gemma, mas disponível para outros modelos)awqsqueezellm- Quantizações da cache KV com os formatos FP8 (ponto flutuante de 8 bits) E5M2 e E4M3.
Para usar a quantização de modelos com o vLLM, os modelos têm de ser pré-quantizados.
Quando iniciar o tempo de execução, defina o parâmetro –quantization.
O fragmento seguinte mostra como otimizar o modelo Gemma 7B
com a quantização awq usando o vLLM no GKE:
Para aplicar esta configuração, use o seguinte comando:
kubectl apply -f vllm/vllm-7b-awq.yaml
Melhore a latência com a quantização da cache KV
Pode usar a quantização da cache KV FP8 E5M2 para diminuir significativamente a memória da cache KV e melhorar a latência, especialmente para tamanhos de lotes grandes. No entanto, isto reduz a precisão da inferência.
Para ativar a quantização da cache KV FP8 E5M2, defina o parâmetro --kv-cache-dtype fp8_e5m2:
Para aplicar esta configuração, use o seguinte comando:
kubectl apply -f vllm/vllm-7b-kvcache.yaml
Prática recomendada: paralelismo de tensores
O paralelismo de tensores é uma técnica que distribui a carga computacional por várias GPUs, o que é essencial quando executa modelos grandes que excedem a capacidade de memória de uma única GPU. Esta abordagem pode ser mais rentável, uma vez que lhe permite usar várias GPUs acessíveis em vez de uma única dispendiosa. Também pode melhorar o débito da inferência do modelo. O paralelismo de tensores tira partido do facto de as operações de tensores poderem ser realizadas de forma independente em partes de dados mais pequenas.
Para saber mais sobre esta técnica, consulte o guia de paralelismo de tensores da Hugging Face.
Selecione um destes separadores para ver um exemplo de aplicação do paralelismo de tensores com as frameworks TGI ou vLLM:
TGI
Com a TGI, o tempo de execução da publicação usa todas as GPUs disponíveis para o pod por predefinição. Pode definir o número de GPUs a usar especificando o parâmetro --num-shard com o número de GPUs como valor.
Consulte a documentação do Hugging Face para ver a lista de modelos suportados para paralelismo de tensores.
O fragmento seguinte mostra como otimizar o modelo ajustado para instruções Gemma 7B usando o paralelismo de tensores e duas GPUs L4:
Para aplicar esta configuração, use o seguinte comando:
kubectl apply -f tgi/tgi-7b-it-tensorparallelism.yaml
Nos clusters do GKE Autopilot, a execução deste comando cria um pod com requisitos mínimos de recursos de 21 vCPUs e 78 GiB de memória.
vLLM
O vLLM suporta a inferência paralela de tensores distribuídos. O vLLM ativa a funcionalidade por predefinição se estiver disponível mais do que uma GPU.
O fragmento seguinte mostra como pode otimizar o modelo ajustado por instruções Gemma 7B usando o paralelismo de tensores e duas GPUs L4:
Para aplicar esta configuração, use o seguinte comando:
kubectl apply -f vllm/vllm-7b-it-tensorparallelism.yaml
Nos clusters do GKE Autopilot, a execução deste comando cria um pod com requisitos mínimos de recursos de 21 vCPUs e 78 GiB de memória.
Prática recomendada: otimização da memória do modelo
A otimização da utilização de memória dos MDIs é crucial para uma inferência eficiente. Esta secção apresenta estratégias de otimização da camada de atenção, como a atenção paginada e a atenção rápida. Estas estratégias melhoram a eficiência da memória, o que permite sequências de entrada mais longas e um tempo de inatividade da GPU reduzido. Esta secção também descreve como pode ajustar os tamanhos de entrada e saída do modelo para se adequarem às restrições de memória e otimizar para frameworks de publicação específicos.
Otimização da camada de atenção
As camadas de autoatenção permitem que os modelos compreendam o contexto nas tarefas de processamento de linguagem, uma vez que os significados das palavras podem mudar consoante o contexto. No entanto, estas camadas armazenam os pesos, as chaves (K) e os valores (V) dos tokens de entrada na vRAM da GPU. Assim, à medida que a sequência de entrada aumenta, isto leva a um crescimento quadrático no tamanho e no tempo de cálculo.
A utilização da colocação em cache de KV é particularmente útil quando está a lidar com sequências de entrada longas, em que a sobrecarga da autoatenção pode tornar-se significativa. Esta abordagem de otimização reduz o processamento computacional para uma complexidade linear.
As técnicas específicas para otimizar os mecanismos de atenção nos GMLs incluem:
- Atenção paginada: a atenção paginada melhora a gestão de memória para modelos grandes e sequências de entrada longas através de técnicas de paginação, semelhantes à memória virtual do SO. Isto reduz eficazmente a fragmentação e a duplicação na cache KV, o que permite sequências de entrada mais longas sem ficar sem memória da GPU.
- Flash attention: o flash attention reduz os gargalos de memória da GPU minimizando as transferências de dados entre a RAM da GPU e a cache L1 durante a geração de tokens. Isto elimina o tempo de inatividade dos núcleos de computação, o que melhora significativamente o desempenho da inferência e da preparação para GPUs.
Ajuste do tamanho da entrada e saída do modelo
Os requisitos de memória dependem do tamanho da entrada e da saída. Uma saída mais longa e mais contexto requerem mais recursos, enquanto uma saída mais curta e menos contexto podem poupar custos através da utilização de uma GPU mais pequena e mais barata.
Selecione um destes separadores para ver um exemplo de ajuste dos requisitos de memória de entrada e saída do modelo nos frameworks TGI ou vLLM:
TGI
O tempo de execução da publicação da TGI verifica os requisitos de memória durante o arranque e não é iniciado se a capacidade de memória do modelo máxima possível não couber na memória da GPU disponível. Esta verificação elimina as falhas de falta de memória (OOM) em cargas de trabalho com utilização intensiva de memória.
O GKE suporta os seguintes parâmetros de TGI para otimizar os requisitos de memória do modelo:
O fragmento seguinte mostra como pode publicar um modelo ajustado com base em instruções do Gemma 7B com uma única GPU L4, com definições de parâmetros--max-total-tokens=3072, --max-batch-prefill-tokens=512,
--max-input-length=512:
Para aplicar esta configuração, use o seguinte comando:
kubectl apply -f tgi/tgi-7b-token.yaml
vLLM
No vLLM, configure o comprimento do contexto do modelo, o que afeta diretamente
o tamanho da cache KV e os requisitos de RAM da GPU. Os comprimentos de contexto mais pequenos permitem a utilização de GPUs mais acessíveis. O valor predefinido é o número máximo de tokens que o modelo aceita. Limite o comprimento máximo do contexto com --max-model-len MAX_MODEL_LEN, se necessário.
Por exemplo, o modelo ajustado de instruções Gemma 7B, com o seu comprimento do contexto predefinido de 8192, excede a capacidade de memória de uma única GPU NVIDIA L4. Para implementar num L4, limite o comprimento combinado dos comandos e das saídas definindo --max-model-len para um valor inferior a 640. Este ajuste permite executar o modelo numa única GPU L4, apesar do seu grande comprimento de contexto predefinido.
Para implementar com o limite de tokens modificado, use o seguinte fragmento:
Para aplicar esta configuração, use o seguinte comando:
kubectl apply -f vllm/vllm-7b-token.yaml
Resumo da lista de verificação
| Objetivo de otimização | Praticar |
|---|---|
| Latência |
|
| Débito |
|
| Relação custo-eficácia |
|
O que se segue?
- Para um guia completo que abrange a configuração do contentor, consulte o artigo Servir um MDG com várias GPUs no GKE.
- Se precisar de uma solução de apresentação de MDIs gerida na nuvem, implemente o seu modelo através do Vertex AI Model Garden.