Publique modelos abertos Gemma com TPUs no GKE com o Saxml

Padrão

---

Aviso: o Saxml no GKE vai ser despriorizado a partir de 24 de abril de 2025. Isto significa que o projeto não vai receber mais atualizações. As implementações do Saxml existentes vão continuar a funcionar sem interrupções. Recomendamos vivamente que migre para o JetStream, o framework de inferência de código aberto atualizado da Google para a publicação de LLMs de alto desempenho em TPUs e GPUs. O JetStream oferece processamento em lote e quantização contínuos para um melhor débito e eficiência de memória. Para ver um exemplo de migração, consulte o artigo Apresente o Gemma com TPUs no GKE com o JetStream.

Este tutorial demonstra como implementar e publicar um grande modelo de linguagem (GML) Gemma 2 usando TPUs no GKE com a framework de publicação Saxml. Este tutorial fornece uma base para compreender e explorar a implementação prática de MDIs para inferência num ambiente Kubernetes gerido. Implementa um contentor pré-criado com o Saxml no GKE. Também configura o GKE para carregar os pesos do Gemma 2B e 7B a partir do Cloud Storage no momento da execução.

Este tutorial destina-se a engenheiros de aprendizagem automática (AA), administradores e operadores de plataformas, bem como a especialistas em dados e IA interessados em usar as capacidades de orquestração de contentores do Kubernetes para publicar MDIs/CEs. Para saber mais sobre as funções comuns e exemplos de tarefas que referimos no Google Cloud conteúdo, consulte Funções e tarefas comuns de utilizadores do GKE.

Antes de ler esta página, certifique-se de que conhece o seguinte:

• Disponibilidade da versão atual da TPU com a arquitetura do sistema Cloud TPU
• TPUs no 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.

Contexto

Esta secção descreve as principais tecnologias usadas neste tutorial.

Gemma

O Gemma é um conjunto de modelos de 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. Pode usar os modelos Gemma para a geração de texto, além de poder otimizar estes modelos para tarefas especializadas.

Para saber mais, consulte a documentação do Gemma.

TPUs

As UTPs são circuitos integrados específicos da aplicação (ASICs) desenvolvidos pela Google e usados para acelerar as estruturas de tratamento de dados, como o TensorFlow, o PyTorch e o JAX.

Este tutorial disponibiliza os modelos Gemma 2B e Gemma 7B. O GKE aloja estes modelos nos seguintes conjuntos de nós TPU v5e de anfitrião único:

• Gemma 2B: modelo ajustado por instruções alojado num conjunto de nós da TPU v5e com uma 1x1 topologia que representa um chip da TPU. O tipo de máquina dos nós é ct5lp-hightpu-1t.
• Gemma 7B: modelo otimizado para instruções alojado num conjunto de nós da TPU v5e com uma 2x2 topologia que representa quatro chips da TPU. O tipo de máquina dos nós é ct5lp-hightpu-4t.

Saxml

O Saxml é um sistema experimental que publica modelos Paxml, JAX e PyTorch para inferência. O sistema Saxml inclui os seguintes componentes:

• Célula Saxml ou cluster Sax: um servidor de administração e um grupo de servidores de modelos. O servidor de administração monitoriza os servidores de modelos, atribui modelos publicados aos servidores de modelos para publicação e ajuda os clientes a localizarem servidores de modelos que publicam modelos específicos.
• Cliente Saxml: a interface de programação virada para o utilizador do sistema Saxml. O cliente Saxml inclui uma ferramenta de linha de comandos (saxutil) e um conjunto de bibliotecas cliente em Python, C++ e Go.

Neste tutorial, também usa o servidor HTTP Saxml. O servidor HTTP Saxml é um servidor HTTP personalizado que encapsula a biblioteca cliente Python Saxml e expõe APIs REST para interagir com o sistema Saxml. As APIs REST incluem pontos finais para publicar, listar, anular a publicação de modelos e gerar previsões.

Objetivos

1. Prepare um cluster do GKE Standard com a topologia de TPU recomendada com base nas caraterísticas do modelo.
2. Implemente componentes Saxml no GKE.
3. Obtenha e publique o modelo de parâmetros Gemma 2B ou Gemma 7B.
4. Publicar e interagir com os modelos publicados.

Arquitetura

Esta secção descreve a arquitetura do GKE usada neste tutorial. A arquitetura compreende um cluster GKE Standard que aprovisiona TPUs e aloja componentes Saxml para implementar e publicar modelos Gemma 2B ou 7B. O diagrama seguinte mostra os componentes desta arquitetura:

Esta arquitetura inclui os seguintes componentes:

• Um cluster zonal padrão do GKE.
• Um conjunto de nós de fatia de TPU de anfitrião único que depende do modelo Gemma que quer publicar:
  • Gemma 2B: configurado com uma TPU v5e com uma 1x1 topologia. Uma instância do servidor do modelo Saxml está configurada para usar este conjunto de nós.
  • Gemma 7B: configurado com uma TPU v5e com uma 2x2 topologia. Uma instância do servidor do modelo Saxml está configurada para usar este conjunto de nós.
• Um conjunto de nós da CPU predefinido onde o servidor de administração do Saxml e o servidor HTTP do Saxml são implementados.
• Dois contentores do Cloud Storage:
  • Um contentor de armazenamento na nuvem armazena o estado gerido por um servidor de administração.
  • Um contentor do Cloud Storage armazena os pontos de verificação do modelo Gemma.

Esta arquitetura tem as seguintes características:

• Um Artifact Registry público gere as imagens de contentores para os componentes do Saxml.
• O cluster do GKE usa a Workload Identity Federation para o GKE. Todos os componentes do Saxml usam uma Workload Identity Federation que integra uma conta de serviço do IAM para aceder a serviços externos, como contentores do Cloud Storage.
• Os registos gerados pelos componentes do Saxml estão integrados no Cloud Logging.
• Pode usar o Cloud Monitoring para analisar as métricas de desempenho dos pools de nós do GKE, como este tutorial cria.

Antes de começar

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

• Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
• Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the required API.

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the API

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

• Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
• Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the required API.

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the API

• Make sure that you have the following role or roles on the project: roles/container.admin, roles/iam.serviceAccountAdmin, roles/iam.policyAdmin, roles/iam.securityAdmin, roles/iam.roleAdmin

  Check for the roles

  1. In the Google Cloud console, go to the IAM page.

     Go to IAM
  2. Select the project.

  3. In the Principal column, find all rows that identify you or a group that you're included in. To learn which groups you're included in, contact your administrator.

  4. For all rows that specify or include you, check the Role column to see whether the list of roles includes the required roles.

  Grant the roles

  1. In the Google Cloud console, go to the IAM page.

     Aceder ao IAM
  2. Selecione o projeto.
  3. Clique em Conceder acesso.

  4. No campo Novos responsáveis, introduza o identificador do utilizador. Normalmente, este é o endereço de email de uma Conta Google.

  5. Na lista Selecionar uma função, selecione uma função.
  6. Para conceder funções adicionais, clique em Adicionar outra função e adicione cada função adicional.
  7. Clique em Guardar.
  • Certifique-se de que tem quotas suficientes para 5 chips de TPU v5e. Neste tutorial, vai usar instâncias a pedido.
  • Crie uma conta do Kaggle, se ainda não tiver uma.

  Prepare o ambiente para o Gemma

  Inicie o Cloud Shell

  Neste tutorial, vai usar o Cloud Shell para gerir recursos alojados no Google Cloud. O Cloud Shell está pré-instalado com o software necessário para este tutorial, incluindo kubectl e a CLI gcloud.

  1. Na Google Cloud consola, inicie uma instância do Cloud Shell:
     Abrir Cloud Shell

  2. Defina as variáveis de ambiente predefinidas:

     gcloud config set project PROJECT_ID
     export PROJECT_ID=$(gcloud config get project)
     export LOCATION=LOCATION
     export CLUSTER_NAME=saxml-tpu
     

     Substitua os seguintes valores:

     • PROJECT_ID: o seu Google Cloud ID do projeto.
     • LOCATION: o nome da zona do Compute Engine onde os tipos de máquinas TPU v5e estão disponíveis.

  Crie um cluster padrão do GKE

  Nesta secção, cria o cluster do GKE e o node pool.

  Gemma 2B-it

  Use o Cloud Shell para fazer o seguinte:

  1. Crie um cluster Standard que use a Federação do Workload Identity para o GKE:

     gcloud container clusters create ${CLUSTER_NAME} \
         --enable-ip-alias \
         --machine-type=e2-standard-4 \
         --num-nodes=2 \
         --release-channel=rapid \
         --workload-pool=${PROJECT_ID}.svc.id.goog \
         --location=${LOCATION}
     

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

  2. Crie um node pool da TPU v5e com uma topologia 1x1 e um nó:

     gcloud container node-pools create tpu-v5e-1x1 \
         --cluster=${CLUSTER_NAME} \
         --machine-type=ct5lp-hightpu-1t \
         --num-nodes=1 \
         --location=${LOCATION}
     

     Publica o modelo Gemma 2B neste conjunto de nós.

  Gemma 7B-it

  Use o Cloud Shell para fazer o seguinte:

  1. Crie um cluster Standard que use a Federação do Workload Identity para o GKE:

     gcloud container clusters create ${CLUSTER_NAME} \
         --enable-ip-alias \
         --machine-type=e2-standard-4 \
         --num-nodes=2 \
         --release-channel=rapid \
         --workload-pool=${PROJECT_ID}.svc.id.goog \
         --location=${LOCATION}
     

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

  2. Crie um node pool da TPU v5e com uma topologia 2x2 e um nó:

     gcloud container node-pools create tpu-v5e-2x2 \
         --cluster=${CLUSTER_NAME} \
         --machine-type=ct5lp-hightpu-4t \
         --num-nodes=1 \
         --location=${LOCATION}
     

     Publica o modelo Gemma 7B neste conjunto de nós.

  Crie os contentores do Cloud Storage

  Crie dois contentores do Cloud Storage para gerir o estado do servidor de administração do Saxml e os pontos de verificação do modelo.

  No Cloud Shell, execute o seguinte:

  1. Crie um contentor do Cloud Storage para armazenar configurações do servidor de administração do Saxml.

     gcloud storage buckets create gs://ADMIN_BUCKET_NAME
     

     Substitua ADMIN_BUCKET_NAME pelo nome do contentor do Cloud Storage que armazena o servidor de administração do SAXML.

  2. Crie um contentor do Cloud Storage para armazenar pontos de verificação do modelo:

     gcloud storage buckets create gs://CHECKPOINTS_BUCKET_NAME
     

     Substitua CHECKPOINTS_BUCKET_NAME pelo nome do contentor do Cloud Storage que armazena os pontos de verificação do modelo.

  Configure o acesso das suas cargas de trabalho através da federação de identidades de cargas de trabalho para o GKE

  Atribua uma conta de serviço do Kubernetes à aplicação e configure essa conta de serviço do Kubernetes para funcionar como uma conta de serviço do IAM.

  1. Configure kubectl para comunicar com o cluster:

     gcloud container clusters get-credentials ${CLUSTER_NAME} --location=${LOCATION}
     

  2. Crie uma ServiceAccount do Kubernetes para a sua aplicação usar:

     gcloud iam service-accounts create wi-sax
     

  3. Adicione uma associação de políticas de IAM para a sua conta de serviço de IAM para ler e escrever no Cloud Storage:

     gcloud projects add-iam-policy-binding ${PROJECT_ID} \
         --member "serviceAccount:wi-sax@${PROJECT_ID}.iam.gserviceaccount.com" \
         --role roles/storage.objectUser
     
     gcloud projects add-iam-policy-binding ${PROJECT_ID} \
         --member "serviceAccount:wi-sax@${PROJECT_ID}.iam.gserviceaccount.com" \
         --role roles/storage.insightsCollectorService
     

  4. Permita que a conta de serviço do Kubernetes use a identidade da conta de serviço da IAM adicionando uma associação de políticas da IAM entre as duas contas de serviço. Esta associação permite que a conta de serviço do Kubernetes atue como a conta de serviço do IAM:

     gcloud iam service-accounts add-iam-policy-binding wi-sax@${PROJECT_ID}.iam.gserviceaccount.com \
         --role roles/iam.workloadIdentityUser \
         --member "serviceAccount:${PROJECT_ID}.svc.id.goog[default/default]"
     

  5. Anotar a conta de serviço do Kubernetes com o endereço de email da conta de serviço do IAM:

     kubectl annotate serviceaccount default \
         iam.gke.io/gcp-service-account=wi-sax@${PROJECT_ID}.iam.gserviceaccount.com
     

  Aceda ao modelo

  Para aceder aos modelos Gemma para implementação no GKE, tem de iniciar sessão na plataforma Kaggle, assinar o contrato de consentimento da licença e obter um token da API Kaggle. Neste tutorial, vai usar um segredo do Kubernetes para as credenciais do Kaggle.

  Assine o contrato de consentimento de licença

  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. Inicie sessão no Kaggle, se ainda não o tiver feito.
  3. Clique em Pedir acesso.
  4. Na secção Escolher conta para consentimento, selecione Validar através da conta do Kaggle para usar a sua conta do Kaggle para conceder consentimento.
  5. Aceite os Termos de Utilização do modelo.

  Gere um token de acesso

  Para aceder ao modelo através do Kaggle, precisa de um token da API Kaggle.

  Siga estes passos para gerar um novo token, se ainda não tiver um:

  1. No navegador, aceda às definições do Kaggle.
  2. Na secção API, clique em Criar novo token.

  O Kaggle transfere um ficheiro denominado kaggle.json.

  Carregue o token de acesso para o Cloud Shell

  No Cloud Shell, pode carregar o token da API Kaggle para o seu Google Cloud projeto:

  1. No Cloud Shell, clique em Mais > Carregar.
  2. Selecione Ficheiro e clique em Escolher ficheiros.
  3. Abra o ficheiro kaggle.json.
  4. Clique em Carregar.

  Crie um segredo do Kubernetes para as credenciais da Kaggle

  No Cloud Shell, siga estes passos:

  1. Configure kubectl para comunicar com o cluster:

     gcloud container clusters get-credentials ${CLUSTER_NAME} --location=${LOCATION}
     

  2. Crie um Secret para armazenar as credenciais do Kaggle:

     kubectl create secret generic kaggle-secret \
         --from-file=kaggle.json
     

  Implemente o Saxml

  Nesta secção, implementa o servidor de administração do Saxml, os servidores de modelos e o servidor HTTP. Este tutorial usa manifestos de implementação 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.

  Implemente o servidor de administração do Saxml

  Nesta secção, implementa o servidor de administração do Saxml.

  1. Crie o seguinte manifesto saxml-admin-server.yaml:

     apiVersion: apps/v1
     kind: Deployment
     metadata:
       name: sax-admin-server
     spec:
       replicas: 1
       selector:
         matchLabels:
           app: sax-admin-server
       template:
         metadata:
           labels:
             app: sax-admin-server
         spec:
           hostNetwork: false
           containers:
           - name: sax-admin-server
             image: us-docker.pkg.dev/cloud-tpu-images/inference/sax-admin-server:v1.2.0
             securityContext:
               privileged: true
             ports:
             - containerPort: 10000
             env:
             - name: GSBUCKET
               value: ADMIN_BUCKET_NAME

     Substitua ADMIN_BUCKET_NAME pelo nome do contentor que criou na secção Crie contentores do Cloud Storage. Não inclua o prefixo gs://.

  2. Aplique o manifesto:

     kubectl apply -f saxml-admin-server.yaml
     

  3. Valide a implementação do servidor de administração:

     kubectl get deployment
     

     O resultado tem um aspeto semelhante ao seguinte:

     NAME                              READY   UP-TO-DATE   AVAILABLE   AGE
     sax-admin-server                  1/1     1            1           ##s
     

  Implemente o servidor de modelos Saxml

  Siga estas instruções para implementar o servidor de modelos para o modelo Gemma 2B ou Gemma 7B.

  Gemma 2B-it

  1. Crie o seguinte manifesto saxml-model-server-1x1.yaml:

     apiVersion: apps/v1
     kind: Deployment
     metadata:
       name: sax-model-server-v5e-1x1
     spec:
       replicas: 1
       selector:
         matchLabels:
           app: gemma-server
       strategy:
         type: Recreate
       template:
         metadata:
           labels:
             app: gemma-server
             ai.gke.io/model: gemma-2b-it
             ai.gke.io/inference-server: saxml
             examples.ai.gke.io/source: user-guide
         spec:
           nodeSelector:
             cloud.google.com/gke-tpu-topology: 1x1
             cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
           hostNetwork: false
           restartPolicy: Always
           containers:
           - name: inference-server
             image: us-docker.pkg.dev/cloud-tpu-images/inference/sax-model-server:v1.2.0
             args:
             - "--jax_platforms=tpu"
             - "--platform_chip=tpuv5e"
             - "--platform_topology=1x1"
             - "--port=10001"
             - "--sax_cell=/sax/test"
             ports:
             - containerPort: 10001
             securityContext:
               privileged: true
             env:
             - name: SAX_ROOT
               value: "gs://ADMIN_BUCKET_NAME/sax-root"
             resources:
               requests:
                 google.com/tpu: 1
               limits:
                 google.com/tpu: 1

     Substitua ADMIN_BUCKET_NAME pelo nome do contentor que criou na secção Crie contentores do Cloud Storage. Não inclua o prefixo gs://.

  2. Aplique o manifesto:

     kubectl apply -f saxml-model-server-1x1.yaml
     

  3. Verifique o estado da implementação do servidor de modelos:

     kubectl get deployment
     

     O resultado tem um aspeto semelhante ao seguinte:

     NAME                                              READY   STATUS    RESTARTS   AGE
     sax-admin-server                                  1/1     Running   0          ##m
     sax-model-server-v5e-1x1                          1/1     Running   0          ##s
     

  Êxito: implementou um servidor de modelos num conjunto de nós de TPU v5e com uma fatia de 1x1 para publicar o modelo Gemma 2B.

  Gemma 7B-it

  1. Crie o seguinte manifesto saxml-model-server-2x2.yaml:

     apiVersion: apps/v1
     kind: Deployment
     metadata:
       name: sax-model-server-v5e-2x2
     spec:
       replicas: 1
       selector:
         matchLabels:
           app: gemma-server
       strategy:
         type: Recreate
       template:
         metadata:
           labels:
             app: gemma-server
             ai.gke.io/model: gemma-7b-it
             ai.gke.io/inference-server: saxml
             examples.ai.gke.io/source: user-guide
         spec:
           nodeSelector:
             cloud.google.com/gke-tpu-topology: 2x2
             cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
           hostNetwork: false
           restartPolicy: Always
           containers:
           - name: inference-server
             image: us-docker.pkg.dev/cloud-tpu-images/inference/sax-model-server:v1.2.0
             args:
             - "--jax_platforms=tpu"
             - "--platform_chip=tpuv5e"
             - "--platform_topology=2x2"
             - "--port=10001"
             - "--sax_cell=/sax/test"
             ports:
             - containerPort: 10001
             securityContext:
               privileged: true
             env:
             - name: SAX_ROOT
               value: "gs://ADMIN_BUCKET_NAME/sax-root"
             resources:
               requests:
                 google.com/tpu: 4
               limits:
                 google.com/tpu: 4

     Substitua ADMIN_BUCKET_NAME pelo nome do contentor que criou na secção Crie contentores do Cloud Storage. Não inclua o prefixo gs://.

  2. Aplique o manifesto:

     kubectl apply -f saxml-model-server-2x2.yaml
     

  3. Verifique o estado da implementação do servidor de modelos:

     kubectl get deployment
     

     O resultado tem um aspeto semelhante ao seguinte:

     NAME                                              READY   STATUS    RESTARTS   AGE
     sax-admin-server                                  1/1     Running   0          ##m
     sax-model-server-v5e-2x2                          1/1     Running   0          ##s
     

  Êxito: implementou um servidor de modelos num conjunto de nós da TPU v5e com uma 2x2fatia para publicar o modelo Gemma 7B.

  Implemente o servidor HTTP Saxml

  Nesta secção, implementa o servidor HTTP Saxml e cria um serviço de IP do cluster que usa para aceder ao servidor.

  1. Crie o seguinte manifesto saxml-http.yaml:

     apiVersion: apps/v1
     kind: Deployment
     metadata:
       name: sax-http
     spec:
       replicas: 1
       selector:
         matchLabels:
           app: sax-http
       template:
         metadata:
           labels:
             app: sax-http
         spec:
           hostNetwork: false
           containers:
           - name: sax-http
             image: us-docker.pkg.dev/cloud-tpu-images/inference/sax-http:v1.2.0
             imagePullPolicy: Always
             ports:
             - containerPort: 8888
             env:
             - name: SAX_ROOT
               value: "gs://ADMIN_BUCKET_NAME/sax-root"
     ---
     apiVersion: v1
     kind: Service
     metadata:
       name: sax-http-svc
     spec:
       selector:
         app: sax-http
       ports:
       - protocol: TCP
         port: 8888
         targetPort: 8888
       type: ClusterIP

     Substitua ADMIN_BUCKET_NAME pelo nome do contentor do Cloud Storage que armazena o servidor de administração do SAXML.

  2. Aplique o manifesto:

     kubectl apply -f saxml-http.yaml
     

  3. Verifique o estado da implementação do servidor HTTP Saxml:

     kubectl get deployment
     

     Gemma 2B-it

     O resultado tem um aspeto semelhante ao seguinte:

     NAME                                              READY   STATUS    RESTARTS   AGE
     sax-admin-server                                  1/1     Running   0          ##m
     sax-model-server-v5e-1x1                          1/1     Running   0          ##m
     sax-http                                          1/1     Running   0          ##s
     

     Gemma 7B-it

     O resultado tem um aspeto semelhante ao seguinte:

     NAME                                              READY   STATUS    RESTARTS   AGE
     sax-admin-server                                  1/1     Running   0          ##m
     sax-model-server-v5e-2x2                          1/1     Running   0          ##m
     sax-http                                          1/1     Running   0          ##s
     

  Transfira o ponto de verificação do modelo

  Nesta secção, executa um trabalho do Kubernetes que obtém, transfere e armazena o ponto de restauro do modelo. Um controlador de tarefas no Kubernetes cria um ou mais pods e garante que executam com êxito uma tarefa específica.

  Siga os passos para o modelo Gemma que quer usar:

  Gemma 2B-it

  1. Crie o seguinte manifesto job-2b.yaml:

     apiVersion: v1
     kind: ConfigMap
     metadata:
       name: fetch-model-scripts
     data:
       fetch_model.sh: |-
         #!/usr/bin/bash -x
         pip install kaggle --break-system-packages && \
     
         MODEL_NAME=$(echo ${MODEL_PATH} | awk -F'/' '{print $2}') && \
         VARIATION_NAME=$(echo ${MODEL_PATH} | awk -F'/' '{print $4}') && \
     
         mkdir -p /data/${MODEL_NAME}_${VARIATION_NAME} &&\
         kaggle models instances versions download ${MODEL_PATH} --untar -p /data/${MODEL_NAME}_${VARIATION_NAME} && \
         echo -e "\nCompleted extraction to /data/${MODEL_NAME}_${VARIATION_NAME}" && \
     
         gcloud storage rsync --recursive --no-clobber /data/${MODEL_NAME}_${VARIATION_NAME} gs://${BUCKET_NAME}/${MODEL_NAME}_${VARIATION_NAME} && \
         echo -e "\nCompleted copy of data to gs://${BUCKET_NAME}/${MODEL_NAME}_${VARIATION_NAME}"
     ---
     apiVersion: batch/v1
     kind: Job
     metadata:
       name: data-loader-2b
       labels:
         app: data-loader-2b
     spec:
       ttlSecondsAfterFinished: 120
       template:
         metadata:
           labels:
             app: data-loader-2b
         spec:
           restartPolicy: OnFailure
           containers:
           - name: gcloud
             image: gcr.io/google.com/cloudsdktool/google-cloud-cli:slim
             command:
             - /scripts/fetch_model.sh
             env:
             - name: BUCKET_NAME
               value: CHECKPOINTS_BUCKET_NAME
             - name: KAGGLE_CONFIG_DIR
               value: /kaggle
             - name: MODEL_PATH
               value: "google/gemma/pax/2b-it/2"
             volumeMounts:
             - mountPath: "/kaggle/"
               name: kaggle-credentials
               readOnly: true
             - mountPath: "/scripts/"
               name: scripts-volume
               readOnly: true
           volumes:
           - name: kaggle-credentials
             secret:
               defaultMode: 0400
               secretName: kaggle-secret
           - name: scripts-volume
             configMap:
               defaultMode: 0700
               name: fetch-model-scripts

     Substitua CHECKPOINTS_BUCKET_NAME pelo nome do contentor que criou na secção Crie contentores do Cloud Storage. Não inclua o prefixo gs://.

  2. Aplique o manifesto:

     kubectl apply -f job-2b.yaml
     

  3. Aguarde a conclusão da tarefa:

     kubectl wait --for=condition=complete --timeout=180s job/data-loader-2b
     

     O resultado tem um aspeto semelhante ao seguinte:

     job.batch/data-loader-2b condition met
     

  4. Verifique se a tarefa foi concluída com êxito:

     kubectl get job/data-loader-2b
     

     O resultado tem um aspeto semelhante ao seguinte:

     NAME             COMPLETIONS   DURATION   AGE
     data-loader-2b   1/1           ##s        #m##s
     

  5. Veja os registos da tarefa:

     kubectl logs --follow job/data-loader-2b
     

  A tarefa carrega o ponto de restauro para gs://CHECKPOINTS_BUCKET_NAME/gemma_2b-it/checkpoint_00000000.

  Gemma 7B-it

  1. Crie o seguinte manifesto job-7b.yaml:

     apiVersion: v1
     kind: ConfigMap
     metadata:
       name: fetch-model-scripts
     data:
       fetch_model.sh: |-
         #!/usr/bin/bash -x
         pip install kaggle --break-system-packages && \
     
         MODEL_NAME=$(echo ${MODEL_PATH} | awk -F'/' '{print $2}') && \
         VARIATION_NAME=$(echo ${MODEL_PATH} | awk -F'/' '{print $4}') && \
     
         mkdir -p /data/${MODEL_NAME}_${VARIATION_NAME} &&\
         kaggle models instances versions download ${MODEL_PATH} --untar -p /data/${MODEL_NAME}_${VARIATION_NAME} && \
         echo -e "\nCompleted extraction to /data/${MODEL_NAME}_${VARIATION_NAME}" && \
     
         gcloud storage rsync --recursive --no-clobber /data/${MODEL_NAME}_${VARIATION_NAME} gs://${BUCKET_NAME}/${MODEL_NAME}_${VARIATION_NAME} && \
         echo -e "\nCompleted copy of data to gs://${BUCKET_NAME}/${MODEL_NAME}_${VARIATION_NAME}"
     ---
     apiVersion: batch/v1
     kind: Job
     metadata:
       name: data-loader-7b
       labels:
         app: data-loader-7b
     spec:
       ttlSecondsAfterFinished: 120
       template:
         metadata:
           labels:
             app: data-loader-7b
         spec:
           restartPolicy: OnFailure
           containers:
           - name: gcloud
             image: gcr.io/google.com/cloudsdktool/google-cloud-cli:slim
             command:
             - /scripts/fetch_model.sh
             env:
             - name: BUCKET_NAME
               value: CHECKPOINTS_BUCKET_NAME
             - name: KAGGLE_CONFIG_DIR
               value: /kaggle
             - name: MODEL_PATH
               value: "google/gemma/pax/7b-it/2"
             volumeMounts:
             - mountPath: "/kaggle/"
               name: kaggle-credentials
               readOnly: true
             - mountPath: "/scripts/"
               name: scripts-volume
               readOnly: true
           volumes:
           - name: kaggle-credentials
             secret:
               defaultMode: 0400
               secretName: kaggle-secret
           - name: scripts-volume
             configMap:
               defaultMode: 0700
               name: fetch-model-scripts

     Substitua CHECKPOINTS_BUCKET_NAME pelo nome do contentor que criou na secção Crie contentores do Cloud Storage. Inclua o prefixo gs://.

  2. Aplique o manifesto:

     kubectl apply -f job-7b.yaml
     

  3. Aguarde a conclusão da tarefa:

     kubectl wait --for=condition=complete --timeout=360s job/data-loader-7b
     

     O resultado tem um aspeto semelhante ao seguinte:

     job.batch/data-loader-7b condition met
     

  4. Verifique se a tarefa foi concluída com êxito:

     kubectl get job/data-loader-7b
     

     O resultado tem um aspeto semelhante ao seguinte:

     NAME             COMPLETIONS   DURATION   AGE
     data-loader-7b   1/1           ##s        #m##s
     

  5. Veja os registos da tarefa:

     kubectl logs --follow job/data-loader-7b
     

  A tarefa carrega o ponto de restauro para gs://CHECKPOINTS_BUCKET_NAME/gemma_7b_it/checkpoint_00000000.

  Exponha o servidor HTTP Saxml

  Pode aceder ao servidor HTTP Saxml através do serviço ClusterIP que criou quando implementou o servidor HTTP Saxml. Os serviços ClusterIP só são acessíveis a partir do cluster. Por conseguinte, para aceder ao serviço a partir do exterior do cluster, conclua os seguintes passos:

  1. Estabeleça uma sessão de encaminhamento de porta:

     kubectl port-forward service/sax-http-svc 8888:8888
     

  2. Verifique se consegue aceder ao servidor HTTP Saxml abrindo um novo terminal e executando o seguinte comando:

     curl -s localhost:8888
     

     O resultado tem um aspeto semelhante ao seguinte:

     {
         "Message": "HTTP Server for SAX Client"
     }
     

  O servidor HTTP Saxml encapsula a interface do cliente para o sistema Saxml e expõe-na através de um conjunto de APIs REST. Use estas APIs para publicar, gerir e interagir com os modelos Gemma 2B e Gemma 7B.

  Publique o modelo Gemma

  Em seguida, pode publicar o modelo Gemma num servidor de modelos que é executado num conjunto de nós de fragmentos de TPU. Usa a API publish do servidor HTTP Saxml para publicar um modelo. Siga estes passos para publicar o modelo de parâmetros Gemma 2B ou 7B.

  Para saber mais sobre a API do servidor HTTP Saxml, consulte o artigo APIs HTTP Saxml.

  Gemma 2B-it

  1. Certifique-se de que a sessão de encaminhamento de portas ainda está ativa:

     curl -s localhost:8888
     

  2. Publicar o parâmetro Gemma 2B:

     curl --request POST \
     --header "Content-type: application/json" \
     -s \
     localhost:8888/publish \
     --data \
     '{
         "model": "/sax/test/gemma2bfp16",
         "model_path": "saxml.server.pax.lm.params.gemma.Gemma2BFP16",
         "checkpoint": "gs://CHECKPOINTS_BUCKET_NAME/gemma_2b-it/checkpoint_00000000",
         "replicas": "1"
     }'
     

     O resultado tem um aspeto semelhante ao seguinte:

     {
         "model": "/sax/test/gemma2bfp16",
         "model_path": "saxml.server.pax.lm.params.gemma.Gemma2BFP16",
         "checkpoint": "gs://CHECKPOINTS_BUCKET_NAME/gemma_2b-it/checkpoint_00000000",
         "replicas": 1
     }
     

     Consulte o passo seguinte para monitorizar o progresso da implementação.

  3. Monitorize o progresso observando os registos num pod do servidor de modelos da implementação sax-model-server-v5e-1x1.

     kubectl logs --follow deployment/sax-model-server-v5e-1x1
     

     Esta implementação pode demorar até cinco minutos a ser concluída. Aguarde até ver uma mensagem semelhante à seguinte:

     I0125 15:34:31.685555 139063071708736 servable_model.py:699] loading completed.
     I0125 15:34:31.686286 139063071708736 model_service_base.py:532] Successfully loaded model for key: /sax/test/gemma2bfp16
     

  4. Confirme se consegue aceder ao modelo apresentando as informações do modelo:

     curl --request GET \
     --header "Content-type: application/json" \
     -s \
     localhost:8888/listcell \
     --data \
     '{
         "model": "/sax/test/gemma2bfp16"
     }'
     

     O resultado tem um aspeto semelhante ao seguinte:

     {
         "model": "/sax/test/gemma2bfp16",
         "model_path": "saxml.server.pax.lm.params.gemma.Gemma2BFP16",
         "checkpoint": "gs://CHECKPOINTS_BUCKET_NAME/gemma_2b-it/checkpoint_00000000",
         "max_replicas": 1,
         "active_replicas": 1
     }
     

  Êxito: publicou um modelo Gemma 2B. Agora, pode interagir com o modelo.

  Gemma 7B-it

  1. Certifique-se de que a sessão de encaminhamento de portas ainda está ativa:

     curl -s localhost:8888
     

  2. Publique o parâmetro Gemma 7B:

     curl --request POST \
     --header "Content-type: application/json" \
     -s \
     localhost:8888/publish \
     --data \
     '{
         "model": "/sax/test/gemma7bfp16",
         "model_path": "saxml.server.pax.lm.params.gemma.Gemma7BFP16",
         "checkpoint": "gs://CHECKPOINTS_BUCKET_NAME/gemma_7b-it/checkpoint_00000000",
         "replicas": "1"
     }'
     

     O resultado tem um aspeto semelhante ao seguinte:

     {
         "model": "/sax/test/gemma7bfp16",
         "model_path": "saxml.server.pax.lm.params.gemma.Gemma7BFP16",
         "checkpoint": "gs://CHECKPOINTS_BUCKET_NAME/gemma_7b-it/checkpoint_00000000",
         "replicas": 1
     }
     

     Consulte o passo seguinte para monitorizar o progresso da implementação.

  3. Monitorize o progresso observando os registos num pod do servidor de modelos da implementação sax-model-server-v5e-2x2.

     kubectl logs --follow deployment/sax-model-server-v5e-2x2
     

     Aguarde até ver uma mensagem semelhante à seguinte:

     I0125 15:34:31.685555 139063071708736 servable_model.py:699] loading completed.
     I0125 15:34:31.686286 139063071708736 model_service_base.py:532] Successfully loaded model for key: /sax/test/gemma7bfp16
     

  4. Verifique se o modelo foi publicado apresentando as informações do modelo:

     curl --request GET \
     --header "Content-type: application/json" \
     -s \
     localhost:8888/listcell \
     --data \
     '{
         "model": "/sax/test/gemma7bfp16"
     }'
     

     O resultado é semelhante ao seguinte:

     {
         "model": "/sax/test/gemma7bfp16",
         "model_path": "saxml.server.pax.lm.params.gemma.Gemma7BFP16",
         "checkpoint": "gs://CHECKPOINTS_BUCKET_NAME/gemma_7b-it/checkpoint_00000000",
         "max_replicas": 1,
         "active_replicas": 1
     }
     

  Êxito: publicou um modelo Gemma 7B. Agora, pode interagir com o modelo.

  Use o modelo

  Pode interagir com os modelos Gemma 2B ou 7B. Use a API generate do servidor HTTP Saxml para enviar um comando ao modelo.

  Gemma 2B-it

  Publique um pedido de comando através do ponto final generate do servidor HTTP Saxml:

  curl --request POST \
  --header "Content-type: application/json" \
  -s \
  localhost:8888/generate \
  --data \
  '{
    "model": "/sax/test/gemma2bfp16",
    "query": "What are the top 5 most popular programming languages?"
  }'
  

  Segue-se um exemplo da resposta do modelo. O resultado real varia com base no comando que apresenta:

  [
      [
          "\n\n1. **Python**\n2. **JavaScript**\n3. **Java**\n4. **C++**\n5. **Go**",
          -3.0704939365386963
      ]
  ]
  

  Pode executar o comando com diferentes parâmetros query. Também pode modificar parâmetros adicionais, como temperature, top_k e topc_p, através da API generate. Para saber mais sobre a API do servidor HTTP Saxml, consulte o artigo APIs HTTP Saxml.

  Gemma 7B-it

  Publique um pedido de comando através do ponto final generate do servidor HTTP Saxml:

  curl --request POST \
  --header "Content-type: application/json" \
  -s \
  localhost:8888/generate \
  --data \
  '{
    "model": "/sax/test/gemma7bfp16",
    "query": "What are the top 5 most popular programming languages?"
  }'
  

  Segue-se um exemplo da resposta do modelo. A saída pode variar em cada comando que publica:

  [
      [
          "\n\n**1. JavaScript**\n\n* Most widely used language on the web.\n* Used for front-end development, such as websites and mobile apps.\n* Extensive libraries and frameworks available.\n\n**2. Python**\n\n* Known for its simplicity and readability.\n* Versatile, used for various tasks, including data science, machine learning, and web development.\n* Large and active community.\n\n**3. Java**\n\n* Object-oriented language widely used in enterprise applications.\n* Used for web applications, mobile apps, and enterprise software.\n* Strong ecosystem and support.\n\n**4. Go**\n\n",
          -16.806324005126953
      ]
  ]
  

  Pode executar o comando com diferentes parâmetros query. Também pode modificar parâmetros adicionais, como temperature, top_k e topc_p, através da API generate. Para saber mais sobre a API do servidor HTTP Saxml, consulte o artigo APIs HTTP Saxml.

  Anule a publicação do modelo

  Siga estes passos para anular a publicação do modelo:

  Gemma 2B-it

  Para anular a publicação do modelo Gemma de 2 mil milhões de parâmetros, execute o seguinte comando:

  curl --request POST \
  --header "Content-type: application/json" \
  -s \
  localhost:8888/unpublish \
  --data \
  '{
      "model": "/sax/test/gemma2bfp16"
  }'
  

  O resultado tem um aspeto semelhante ao seguinte:

  {
      "model": "/sax/test/gemma2bfp16"
  }
  

  Pode executar o comando com diferentes comandos que são transmitidos no parâmetro query.

  Gemma 7B-it

  Para anular a publicação do modelo Gemma 7B-it, execute o seguinte comando:

  curl --request POST \
  --header "Content-type: application/json" \
  -s \
  localhost:8888/unpublish \
  --data \
  '{
      "model": "/sax/test/gemma7bfp16"
  }'
  

  O resultado tem um aspeto semelhante ao seguinte:

  {
      "model": "/sax/test/gemma7bfp16"
  }
  

  Pode executar o comando com diferentes comandos que são transmitidos no parâmetro query.

  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 mensagem Connected, que indica que o modelo está pronto para publicação.
  • Se vir Connection refused, verifique se o encaminhamento de portas está ativo.

  Limpar

  Para evitar incorrer em custos na sua conta do Google Cloud pelos recursos usados neste tutorial, elimine o projeto que contém os recursos ou mantenha o projeto e elimine os recursos individuais.

  Elimine os recursos implementados

  Para evitar incorrer em custos na sua Google Cloud conta pelos recursos que criou neste guia, execute o seguinte comando:

  gcloud container clusters delete ${CLUSTER_NAME} --location=${LOCATION}
  gcloud iam service-accounts delete --quiet wi-sax@${PROJECT_ID}.iam.gserviceaccount.com
  gcloud storage rm --recursive gs://ADMIN_BUCKET_NAME
  gcloud storage rm --recursive gs://CHECKPOINTS_BUCKET_NAME
  

  Substitua o seguinte:

  • ADMIN_BUCKET_NAME: o nome do contentor do Cloud Storage que armazena o servidor de administração do SAXML.
  • CHECKPOINTS_BUCKET_NAME: o nome do contentor do Cloud Storage que armazena os pontos de verificação do modelo.

  O que se segue?

  • Saiba mais sobre as TPUs no GKE.
  • Explore o repositório do GitHub do Saxml, incluindo as APIs HTTP do Saxml.
  • Explore o Vertex AI Model Garden.
  • Descubra como executar cargas de trabalho de IA/ML otimizadas com as capacidades de orquestração da plataforma do GKE.
  • Explore arquiteturas de referência, diagramas e práticas recomendadas sobre o Google Cloud. Consulte o nosso Centro de arquitetura na nuvem.