Este tutorial mostra como implementar e publicar modelos de linguagem (conteúdo extenso) (MDI/CE) usando GPUs no Google Kubernetes Engine (GKE) com a framework de publicação Text Generation Inference (TGI) da Hugging Face. Este tutorial fornece uma base para compreender e explorar a implementação prática de MDIs/CEs para inferência num ambiente Kubernetes gerido. Implementa um contentor pré-criado que executa o TGI no GKE. Também configura o GKE para carregar os pesos do Gemma 2B, 9B e 27B a partir do Hugging Face.
Este tutorial destina-se a engenheiros de aprendizagem automática (AA), administradores e operadores de plataformas, e especialistas em dados e IA que tenham interesse em usar as capacidades de orquestração de contentores do Kubernetes para fornecer GMLs no hardware de GPU H100, A100 e L4. Para saber mais sobre as funções comuns e as tarefas de exemplo a que fazemos referência no Google Cloud conteúdo, consulte o artigo Funções e tarefas comuns do utilizador do GKE.
Se precisar de uma plataforma de IA gerida unificada para criar e apresentar rapidamente modelos de ML de forma económica, recomendamos que experimente a nossa solução de implementação do Vertex AI.
Antes de ler esta página, certifique-se de que conhece o seguinte:
Contexto
Esta secção descreve as principais tecnologias usadas neste guia.
Gemma
O Gemma é um conjunto de modelos de inteligência artificial (IA) generativa leves e disponíveis abertamente, lançados ao abrigo de uma licença aberta. Estes modelos de IA estão disponíveis para execução nas suas aplicações, hardware, dispositivos móveis ou serviços alojados.
Neste guia, apresentamos os seguintes modelos:
- Gemma para geração de texto, também pode otimizar estes modelos para se especializarem na realização de tarefas específicas.
- O CodeGemma é uma coleção de modelos poderosos e leves que podem realizar uma variedade de tarefas de programação, como preenchimento de código, geração de código, compreensão de linguagem natural, raciocínio matemático e seguimento de instruções.
Para saber mais, consulte a documentação do Gemma.
GPUs
As GPUs permitem-lhe acelerar cargas de trabalho específicas executadas nos seus nós, como a aprendizagem automática e o processamento de dados. O GKE oferece uma variedade de opções de tipos de máquinas para a configuração de nós, incluindo tipos de máquinas com GPUs NVIDIA H100, L4 e A100.
Text Generation Inference (TGI)
O TGI é o conjunto de ferramentas da Hugging Face para implementar e disponibilizar MDIs. A TGI permite a geração de texto de alto desempenho para MDIs de código aberto populares, incluindo o Gemma. O TGI inclui funcionalidades como:
- Implementação otimizada do transformador com Flash Attention e PagedAttention
- Processamento em lote contínuo para melhorar o débito geral da publicação
- Paralelismo de tensores para uma inferência mais rápida em várias GPUs
Para saber mais, consulte a documentação da TGI.
Aceda ao modelo
Para aceder aos modelos Gemma para implementação no GKE, primeiro tem de assinar o contrato de consentimento de licença e, em seguida, gerar um token de acesso do Hugging Face.
Assine o contrato de consentimento de licença
Tem de assinar o contrato de consentimento para usar o Gemma. Siga estas instruções:
- Aceda à página de consentimento do modelo em Kaggle.com.
- Valide o consentimento através da sua conta do Hugging Face.
- Aceite os termos do modelo.
Gere um token de acesso
Para aceder ao modelo através do Hugging Face, precisa de um token do Hugging Face.
Siga estes passos para gerar um novo token se ainda não tiver um:
- Clique em O seu perfil > Definições > Tokens de acesso.
- Selecione Novo token.
- Especifique um nome à sua escolha e uma função de, pelo menos,
Read. - Selecione Gerar um token.
- Copie o token gerado para a área de transferência.
Prepare o seu ambiente
Neste tutorial, vai usar o Cloud Shell para gerir recursos alojados no
Google Cloud. O Cloud Shell vem pré-instalado com o software de que precisa para este tutorial, incluindo o kubectl e a
CLI gcloud.
Para configurar o seu ambiente com o Cloud Shell, siga estes passos:
Na Google Cloud consola, inicie uma sessão do Cloud Shell clicando em
Ativar Cloud Shell na Google Cloud consola. Esta ação inicia uma sessão no painel inferior da consola. Google Cloud Defina as variáveis de ambiente predefinidas:
gcloud config set project PROJECT_ID gcloud config set billing/quota_project PROJECT_ID export PROJECT_ID=$(gcloud config get project) export CONTROL_PLANE_LOCATION=CONTROL_PLANE_LOCATION export CLUSTER_NAME=CLUSTER_NAME export HF_TOKEN=HF_TOKENSubstitua os seguintes valores:
PROJECT_ID: o seu Google Cloud ID do projeto.CONTROL_PLANE_LOCATION: a região do Compute Engine do plano de controlo do seu cluster. Esta região tem de suportar o tipo de acelerador que quer usar, por exemplo,us-central1para a GPU L4.CLUSTER_NAME: o nome do cluster.HF_TOKEN: o token do Hugging Face que gerou anteriormente.
Crie e configure Google Cloud recursos
Siga estas instruções para criar os recursos necessários.
Crie um cluster e um node pool do GKE
Pode publicar o Gemma em GPUs num cluster do GKE Autopilot ou Standard. Recomendamos que use um cluster do Autopilot para uma experiência do Kubernetes totalmente gerida. Para escolher o modo de funcionamento do GKE mais adequado às suas cargas de trabalho, consulte o artigo Escolha um modo de funcionamento do GKE.
Piloto automático
No Cloud Shell, execute o seguinte comando:
gcloud container clusters create-auto CLUSTER_NAME \
--project=PROJECT_ID \
--location=CONTROL_PLANE_LOCATION \
--release-channel=rapid
Substitua os seguintes valores:
PROJECT_ID: o seu Google Cloud ID do projeto.CONTROL_PLANE_LOCATION: a região do Compute Engine do plano de controlo do seu cluster. Esta região tem de suportar o tipo de acelerador que quer usar, por exemplo,us-central1para a GPU L4.CLUSTER_NAME: o nome do cluster.
O GKE cria um cluster do Autopilot com nós de CPU e GPU, conforme solicitado pelas cargas de trabalho implementadas.
Standard
No Cloud Shell, execute o seguinte comando para criar um cluster Standard:
gcloud container clusters create CLUSTER_NAME \ --project=PROJECT_ID \ --location=CONTROL_PLANE_LOCATION \ --workload-pool=PROJECT_ID.svc.id.goog \ --release-channel=rapid \ --num-nodes=1Substitua os seguintes valores:
PROJECT_ID: o seu Google Cloud ID do projeto.CONTROL_PLANE_LOCATION: a região do Compute Engine do plano de controlo do seu cluster. Esta região tem de suportar o tipo de acelerador que quer usar, por exemplo,us-central1para a GPU L4.CLUSTER_NAME: o nome do cluster.
A criação do cluster pode demorar vários minutos.
Para criar um node pool para o seu cluster com o tamanho do disco adequado, execute o seguinte comando:
Gemma 2 2B
gcloud container node-pools create gpupool \ --accelerator type=nvidia-l4,count=1,gpu-driver-version=latest \ --project=PROJECT_ID \ --location=CONTROL_PLANE_LOCATION \ --node-locations=CONTROL_PLANE_LOCATION-a \ --cluster=CLUSTER_NAME \ --machine-type=g2-standard-8 \ --num-nodes=1O GKE cria um único node pool que contém uma GPU L4 para cada nó.
Gemma 2 9B
gcloud container node-pools create gpupool \ --accelerator type=nvidia-l4,count=2,gpu-driver-version=latest \ --project=PROJECT_ID \ --location=CONTROL_PLANE_LOCATION \ --node-locations=CONTROL_PLANE_LOCATION-a \ --cluster=CLUSTER_NAME \ --machine-type=g2-standard-24 \ --num-nodes=1O GKE cria um único node pool que contém duas GPUs L4 para cada nó.
Gemma 2 27B
gcloud container node-pools create gpupool \ --accelerator type=nvidia-l4,count=4,gpu-driver-version=latest \ --project=PROJECT_ID \ --location=CONTROL_PLANE_LOCATION \ --node-locations=CONTROL_PLANE_LOCATION-a \ --cluster=CLUSTER_NAME \ --machine-type=g2-standard-48 \ --num-nodes=1 \ --disk-size=180O GKE cria um único node pool com quatro GPUs L4 para cada nó.
Crie um segredo do Kubernetes para as credenciais do Hugging Face
No Cloud Shell, faça o seguinte:
Configure
kubectlpara comunicar com o cluster:gcloud container clusters get-credentials CLUSTER_NAME \ --location=CONTROL_PLANE_LOCATIONCrie um segredo do Kubernetes que contenha o token do Hugging Face:
kubectl create secret generic hf-secret \ --from-literal=hf_api_token=HF_TOKEN \ --dry-run=client -o yaml | kubectl apply -f -Substitua
HF_TOKENpelo token do Hugging Face que gerou anteriormente.
Implemente a TGI
Nesta secção, implementa o contentor TGI para publicar o modelo Gemma que quer usar. Para implementar o modelo, este tutorial usa implementações do Kubernetes. Uma implementação é um objeto da API Kubernetes que lhe permite executar várias réplicas de pods distribuídas entre os nós num cluster.
Gemma 2 2B-it
Siga estas instruções para implementar o modelo otimizado para instruções Gemma 2B.
Crie o seguinte manifesto
tgi-2-2b-it.yaml:Aplique o manifesto:
kubectl apply -f tgi-2-2b-it.yaml
Gemma 2 de 9 mil milhões de parâmetros
Siga estas instruções para implementar o modelo ajustado por instruções Gemma 9B.
Crie o seguinte manifesto
tgi-2-9b-it.yaml:Aplique o manifesto:
kubectl apply -f tgi-2-9b-it.yaml
Gemma 2 de 27 mil milhões de parâmetros
Siga estas instruções para implementar o modelo otimizado para instruções Gemma 2 27B.
Crie o seguinte manifesto
tgi-2-27b-it.yaml:Aplique o manifesto:
kubectl apply -f tgi-2-27b-it.yaml
CodeGemma 7B-it
Siga estas instruções para implementar o modelo otimizado para instruções CodeGemma 7B.
Crie o seguinte manifesto
tgi-codegemma-1.1-7b-it.yaml:Aplique o manifesto:
kubectl apply -f tgi-codegemma-1.1-7b-it.yaml
Publique o modelo
Nesta secção, interage com o modelo.
Configure o encaminhamento de portas
Execute o seguinte comando para configurar o encaminhamento de portas para o modelo:
kubectl port-forward service/llm-service 8000:8000
O resultado é semelhante ao seguinte:
Forwarding from 127.0.0.1:8000 -> 8000
Interaja com o modelo através do curl
Esta secção mostra como pode realizar um teste de verificação de compilação básico para validar os modelos pré-treinados ou ajustados por instruções implementados. Para simplificar, esta secção descreve a abordagem de testes com os modelos Gemma 2 com ajuste fino de instruções e CodeGemma.
Gemma 2
Numa nova sessão de terminal, use curl para conversar com o seu modelo:
USER_PROMPT="I'm new to coding. If you could only recommend one programming language to start with, what would it be and why?"
curl -X POST http://localhost:8000/generate \
-H "Content-Type: application/json" \
-d @- <<EOF
{
"inputs": "<start_of_turn>user\n${USER_PROMPT}<end_of_turn>\n",
"parameters": {
"temperature": 0.90,
"top_p": 0.95,
"max_new_tokens": 128
}
}
EOF
A saída seguinte mostra um exemplo da resposta do modelo:
{"generated_text":"**Python**\n\n**Reasons why Python is a great choice for beginners:**\n\n* **Simple syntax:** Python uses clear and concise syntax, making it easy for beginners to pick up.\n* **Easy to learn:** Python's syntax is based on English, making it easier to learn than other languages.\n* **Large and supportive community:** Python has a massive and active community of developers who are constantly willing to help.\n* **Numerous libraries and tools:** Python comes with a vast collection of libraries and tools that make it easy to perform various tasks, such as data manipulation, web development, and machine learning.\n* **"}
CodeGemma
Numa nova sessão de terminal, use curl para conversar com o seu modelo:
USER_PROMPT="Generate a python code example of a adding two numbers from a function called addNumbers"
curl -s -X POST http://localhost:8000/generate \
-H "Content-Type: application/json" \
-d @- <<EOF | jq -r .generated_text
{
"inputs": "<start_of_turn>user\n${USER_PROMPT}<end_of_turn>\n",
"parameters": {
"temperature": 0.90,
"top_p": 0.95,
"max_new_tokens": 2000
}
}
EOF
A saída seguinte mostra um exemplo da resposta do modelo:
def addNumbers(num1, num2):
sum = num1 + num2
return sum
# Get the input from the user
num1 = float(input("Enter the first number: "))
num2 = float(input("Enter the second number: "))
# Call the addNumbers function
sum = addNumbers(num1, num2)
# Print the result
print("The sum of", num1, "and", num2, "is", sum)
(Opcional) Interagir com o modelo através de uma interface de chat do Gradio
Nesta secção, vai criar uma aplicação de chat Web que lhe permite interagir com o seu modelo ajustado por instruções. Para simplificar, esta secção descreve apenas a abordagem de testes com o modelo 2B-it.
O Gradio é uma biblioteca Python que tem um wrapper ChatInterface que cria interfaces do utilizador para chatbots.
Implemente a interface do chat
No Cloud Shell, guarde o seguinte manifesto como
gradio.yaml:Aplique o manifesto:
kubectl apply -f gradio.yamlAguarde até que a implementação esteja disponível:
kubectl wait --for=condition=Available --timeout=300s deployment/gradio
Use a interface de chat
No Cloud Shell, execute o seguinte comando:
kubectl port-forward service/gradio 8080:8080Isto cria um encaminhamento de porta do Cloud Shell para o serviço Gradio.
Clique no botão
Pré-visualização Web, que se encontra na parte superior direita da barra de tarefas do Cloud Shell. Clique em Pré-visualizar na porta 8080. É aberto um novo separador no navegador.Interaja com o Gemma através da interface de chat do Gradio. Adicione uma mensagem e clique em Enviar.
Resolver problemas
- Se receber a mensagem
Empty reply from server, é possível que o contentor não tenha terminado de transferir os dados do modelo. Verifique novamente os registos do Pod para ver a mensagemConnected, que indica que o modelo está pronto para publicação. - Se vir
Connection refused, verifique se o encaminhamento de portas está ativo.
Observe o desempenho do modelo
Para observar o desempenho do modelo, pode usar a integração do painel de controlo da TGI no Cloud Monitoring. Com este painel de controlo, pode ver métricas de desempenho críticas, como o débito de tokens, a latência de pedidos e as taxas de erro.
Para usar o painel de controlo da TGI, tem de ativar o Google Cloud Managed Service for Prometheus, que recolhe as métricas da TGI, no seu cluster do GKE. Por predefinição, o TGI expõe métricas no formato Prometheus; não precisa de instalar um exportador adicional.
Em seguida, pode ver as métricas através do painel de controlo do TGI. Para obter informações sobre a utilização do serviço gerido do Google Cloud para Prometheus para recolher métricas do seu modelo, consulte as orientações de observabilidade da TGI na documentação do Cloud Monitoring.