Publique modelos abertos Gemma com GPUs no GKE com o TGI do Hugging Face

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:

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.

Tem de assinar o contrato de consentimento para usar o Gemma. Siga estas instruções:

  1. Aceda à página de consentimento do modelo em Kaggle.com.
  2. Valide o consentimento através da sua conta do Hugging Face.
  3. 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:

  1. Clique em O seu perfil > Definições > Tokens de acesso.
  2. Selecione Novo token.
  3. Especifique um nome à sua escolha e uma função de, pelo menos, Read.
  4. Selecione Gerar um token.
  5. 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:

  1. Na Google Cloud consola, inicie uma sessão do Cloud Shell clicando em Ícone de ativação do Cloud Shell Ativar Cloud Shell na Google Cloud consola. Esta ação inicia uma sessão no painel inferior da consola. Google Cloud

  2. 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_TOKEN

    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-central1 para 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-central1 para 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

  1. 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=1

    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-central1 para a GPU L4.
    • CLUSTER_NAME: o nome do cluster.

    A criação do cluster pode demorar vários minutos.

  2. 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=1

    O 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=1

    O 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=180

    O 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:

  1. Configure kubectl para comunicar com o cluster:

    gcloud container clusters get-credentials CLUSTER_NAME \     --location=CONTROL_PLANE_LOCATION

  2. Crie 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_TOKEN pelo 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.

  1. Crie o seguinte manifesto tgi-2-2b-it.yaml:

    apiVersion: apps/v1 kind: Deployment metadata:   name: tgi-gemma-deployment spec:   replicas: 1   selector:     matchLabels:       app: gemma-server   template:     metadata:       labels:         app: gemma-server         ai.gke.io/model: gemma-2-2b-it         ai.gke.io/inference-server: text-generation-inference         examples.ai.gke.io/source: user-guide     spec:       containers:       - name: inference-server         image: us-docker.pkg.dev/deeplearning-platform-release/gcr.io/huggingface-text-generation-inference-cu124.2-3.ubuntu2204.py311         resources:           requests:             cpu: "2"             memory: "10Gi"             ephemeral-storage: "10Gi"             nvidia.com/gpu: "1"           limits:             cpu: "2"             memory: "10Gi"             ephemeral-storage: "10Gi"             nvidia.com/gpu: "1"         env:         - name: AIP_HTTP_PORT           value: '8000'         - name: NUM_SHARD           value: '1'         - name: MAX_INPUT_LENGTH           value: '1562'         - name: MAX_TOTAL_TOKENS           value: '2048'         - name: MAX_BATCH_PREFILL_TOKENS           value: '2048'         - name: CUDA_MEMORY_FRACTION           value: '0.93'         - name: MODEL_ID           value: google/gemma-2-2b-it         - name: HUGGING_FACE_HUB_TOKEN           valueFrom:             secretKeyRef:               name: hf-secret               key: hf_api_token         volumeMounts:         - mountPath: /dev/shm           name: dshm       volumes:       - name: dshm         emptyDir:           medium: Memory       nodeSelector:         cloud.google.com/gke-accelerator: nvidia-l4 --- apiVersion: v1 kind: Service metadata:   name: llm-service spec:   selector:     app: gemma-server   type: ClusterIP   ports:   - protocol: TCP     port: 8000     targetPort: 8000

  2. 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.

  1. Crie o seguinte manifesto tgi-2-9b-it.yaml:

    apiVersion: apps/v1 kind: Deployment metadata:   name: tgi-gemma-deployment spec:   replicas: 1   selector:     matchLabels:       app: gemma-server   template:     metadata:       labels:         app: gemma-server         ai.gke.io/model: gemma-2-9b-it         ai.gke.io/inference-server: text-generation-inference         examples.ai.gke.io/source: user-guide     spec:       containers:       - name: inference-server         image: us-docker.pkg.dev/deeplearning-platform-release/gcr.io/huggingface-text-generation-inference-cu124.2-3.ubuntu2204.py311         resources:           requests:             cpu: "4"             memory: "30Gi"             ephemeral-storage: "30Gi"             nvidia.com/gpu: "2"           limits:             cpu: "4"             memory: "30Gi"             ephemeral-storage: "30Gi"             nvidia.com/gpu: "2"         env:         - name: AIP_HTTP_PORT           value: '8000'         - name: NUM_SHARD           value: '2'         - name: MAX_INPUT_LENGTH           value: '1562'         - name: MAX_TOTAL_TOKENS           value: '2048'         - name: MAX_BATCH_PREFILL_TOKENS           value: '2048'         - name: CUDA_MEMORY_FRACTION           value: '0.93'         - name: MODEL_ID           value: google/gemma-2-9b-it         - name: HUGGING_FACE_HUB_TOKEN           valueFrom:             secretKeyRef:               name: hf-secret               key: hf_api_token         volumeMounts:         - mountPath: /dev/shm           name: dshm       volumes:       - name: dshm         emptyDir:           medium: Memory       nodeSelector:         cloud.google.com/gke-accelerator: nvidia-l4 --- apiVersion: v1 kind: Service metadata:   name: llm-service spec:   selector:     app: gemma-server   type: ClusterIP   ports:   - protocol: TCP     port: 8000     targetPort: 8000

  2. 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.

  1. Crie o seguinte manifesto tgi-2-27b-it.yaml:

    apiVersion: apps/v1 kind: Deployment metadata:   name: tgi-gemma-deployment spec:   replicas: 1   selector:     matchLabels:       app: gemma-server   template:     metadata:       labels:         app: gemma-server         ai.gke.io/model: gemma-2-27b-it         ai.gke.io/inference-server: text-generation-inference         examples.ai.gke.io/source: user-guide     spec:       containers:       - name: inference-server         image: us-docker.pkg.dev/deeplearning-platform-release/gcr.io/huggingface-text-generation-inference-cu124.2-3.ubuntu2204.py311         resources:           requests:             cpu: "10"             memory: "80Gi"             ephemeral-storage: "80Gi"             nvidia.com/gpu: "4"           limits:             cpu: "10"             memory: "80Gi"             ephemeral-storage: "80Gi"             nvidia.com/gpu: "4"         env:         - name: AIP_HTTP_PORT           value: '8000'         - name: NUM_SHARD           value: '4'         - name: MAX_INPUT_LENGTH           value: '1562'         - name: MAX_TOTAL_TOKENS           value: '2048'         - name: MAX_BATCH_PREFILL_TOKENS           value: '2048'         - name: CUDA_MEMORY_FRACTION           value: '0.93'         - name: MODEL_ID           value: google/gemma-2-27b-it         - name: HUGGING_FACE_HUB_TOKEN           valueFrom:             secretKeyRef:               name: hf-secret               key: hf_api_token         volumeMounts:         - mountPath: /dev/shm           name: dshm       volumes:       - name: dshm         emptyDir:           medium: Memory       nodeSelector:         cloud.google.com/gke-accelerator: nvidia-l4 --- apiVersion: v1 kind: Service metadata:   name: llm-service spec:   selector:     app: gemma-server   type: ClusterIP   ports:   - protocol: TCP     port: 8000     targetPort: 8000

  2. 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.

  1. Crie o seguinte manifesto tgi-codegemma-1.1-7b-it.yaml:

    apiVersion: apps/v1 kind: Deployment metadata:   name: tgi-gemma-deployment spec:   replicas: 1   selector:     matchLabels:       app: gemma-server   template:     metadata:       labels:         app: gemma-server         ai.gke.io/model: codegemma-1.1-7b-it         ai.gke.io/inference-server: text-generation-inference         examples.ai.gke.io/source: user-guide     spec:       containers:       - name: inference-server         image: us-docker.pkg.dev/deeplearning-platform-release/gcr.io/huggingface-text-generation-inference-cu124.2-3.ubuntu2204.py311         resources:           requests:             cpu: "2"             memory: "25Gi"             ephemeral-storage: "40Gi"             nvidia.com/gpu: 2           limits:             cpu: "10"             memory: "25Gi"             ephemeral-storage: "40Gi"             nvidia.com/gpu: 2         args:         - --model-id=$(MODEL_ID)         - --num-shard=2         env:         - name: MODEL_ID           value: google/codegemma-1.1-7b-it         - name: PORT           value: "8000"         - name: HUGGING_FACE_HUB_TOKEN           valueFrom:             secretKeyRef:               name: hf-secret               key: hf_api_token         volumeMounts:         - mountPath: /dev/shm           name: dshm       volumes:       - name: dshm         emptyDir:           medium: Memory       nodeSelector:         cloud.google.com/gke-accelerator: nvidia-l4 --- apiVersion: v1 kind: Service metadata:   name: llm-service spec:   selector:     app: gemma-server   type: ClusterIP   ports:     - protocol: TCP       port: 8000       targetPort: 8000

  2. 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

  1. No Cloud Shell, guarde o seguinte manifesto como gradio.yaml:

    apiVersion: apps/v1 kind: Deployment metadata:   name: gradio   labels:     app: gradio spec:   replicas: 1   selector:     matchLabels:       app: gradio   template:     metadata:       labels:         app: gradio     spec:       containers:       - name: gradio         image: us-docker.pkg.dev/google-samples/containers/gke/gradio-app:v1.0.4         resources:           requests:             cpu: "250m"             memory: "512Mi"           limits:             cpu: "500m"             memory: "512Mi"         env:         - name: CONTEXT_PATH           value: "/generate"         - name: HOST           value: "http://llm-service:8000"         - name: LLM_ENGINE           value: "tgi"         - name: MODEL_ID           value: "gemma"         - name: USER_PROMPT           value: "<start_of_turn>user\nprompt<end_of_turn>\n"         - name: SYSTEM_PROMPT           value: "<start_of_turn>model\nprompt<end_of_turn>\n"         ports:         - containerPort: 7860 --- apiVersion: v1 kind: Service metadata:   name: gradio spec:   selector:     app: gradio   ports:   - protocol: TCP     port: 8080     targetPort: 7860   type: ClusterIP

  2. Aplique o manifesto:

    kubectl apply -f gradio.yaml

  3. Aguarde até que a implementação esteja disponível:

    kubectl wait --for=condition=Available --timeout=300s deployment/gradio

Use a interface de chat

  1. No Cloud Shell, execute o seguinte comando:

    kubectl port-forward service/gradio 8080:8080

    Isto cria um encaminhamento de porta do Cloud Shell para o serviço Gradio.

  2. Clique no botão Ícone de pré-visualização da Web 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.

  3. Interaja com o Gemma através da interface de chat do Gradio. Adicione uma mensagem e clique em Enviar.

Resolver problemas

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.