Implemente o Gemma com TPUs no GKE com o JetStream

Autopilot Padrão

Este tutorial mostra como publicar um modelo de linguagem (conteúdo extenso) (MDL/CE) Gemma usando unidades de processamento tensor (TPUs) no Google Kubernetes Engine (GKE). Implementa um contentor pré-criado com o JetStream e o MaxText no GKE. Também pode configurar o GKE para carregar os pesos do Gemma 7B a partir do Cloud Storage no tempo de 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 capacidades de orquestração de contentores do Kubernetes para publicar MDIs/CEs. Para saber mais sobre as funções comuns e as tarefas de exemplo que referimos no Google Cloud conteúdo, consulte Funções e tarefas comuns do utilizador do GKE.

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

• Modo Autopilot e modo Standard
• Disponibilidade da versão atual da TPU com a arquitetura do sistema Cloud TPU
• TPUs no GKE

Contexto

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

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. Pode usar os modelos Gemma para a geração de texto. No entanto, também pode ajustar estes modelos para tarefas especializadas.

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

TPUs

As TPUs são circuitos integrados específicos da aplicação (ASICs) desenvolvidos pela Google e usados para acelerar a aprendizagem automática e os modelos de IA criados com frameworks como o TensorFlow, o PyTorch e o JAX.

Este tutorial aborda a publicação do modelo Gemma 7B. O GKE implementa o modelo em nós TPUv5e de anfitrião único com topologias de TPU configuradas com base nos requisitos do modelo para publicar comandos com baixa latência.

JetStream

O JetStream é uma framework de fornecimento de inferência de código aberto desenvolvida pela Google. O JetStream permite uma inferência de alto desempenho, com elevado débito e otimizada em função da memória em TPUs e GPUs. Oferece otimizações de desempenho avançadas, incluindo técnicas de quantização e processamento em lote contínuo, para facilitar a implementação de MDIs. O JetStream permite a publicação de TPUs do PyTorch/XLA e JAX para alcançar um desempenho ideal.

Para saber mais acerca destas otimizações, consulte os repositórios dos projetos JetStream PyTorch e JetStream MaxText.

MaxText

O MaxText é uma implementação de LLM JAX de alto desempenho, escalável e adaptável, criada com base em bibliotecas JAX de código aberto, como o Flax, o Orbax e o Optax. A implementação do LLM apenas com descodificador do MaxText está escrita em Python. Tira partido do compilador XLA para alcançar um elevado desempenho sem precisar de criar kernels personalizados.

Para saber mais sobre os modelos e os tamanhos de parâmetros mais recentes suportados pelo MaxText, consulte o repositório do projeto MaxText.

Objetivos

1. Prepare um cluster do GKE Autopilot ou Standard com a topologia de TPU recomendada com base nas caraterísticas do modelo.
2. Implemente componentes do JetStream no GKE.
3. Obtenha e publique o modelo preparado com instruções Gemma 7B.
4. Publicar e interagir com o modelo publicado.

Arquitetura

Esta secção descreve a arquitetura do GKE usada neste tutorial. A arquitetura compreende um cluster do GKE Autopilot ou Standard que aprovisiona TPUs e aloja componentes do JetStream para implementar e publicar os modelos.

O diagrama seguinte mostra os componentes desta arquitetura:

Esta arquitetura inclui os seguintes componentes:

• Um cluster regional do GKE Autopilot ou Standard.
• Dois pools de nós de fatias de TPUs de anfitrião único que alojam a implementação do JetStream.
• O componente Service distribui o tráfego de entrada por todas as réplicas JetStream HTTP.
• JetStream HTTP é um servidor HTTP que aceita pedidos como um wrapper para o formato necessário do JetStream e envia-o para o cliente GRPC do JetStream.
• O Maxengine é um servidor JetStream que realiza inferências com processamento em lote contínuo.

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/resourcemanager.projectIamAdmin

  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 quota suficiente para oito chips TPU v5e PodSlice Lite. Neste tutorial, vai usar instâncias a pedido.
  • Crie uma conta do Kaggle, se ainda não tiver uma.

  Aceda ao modelo

  Para aceder ao modelo Gemma para implementação no GKE, tem de assinar primeiro o contrato de consentimento da licença.

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

  É transferido um ficheiro com o nome kaggle.json.

  Prepare o 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 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 CLUSTER_NAME=CLUSTER_NAME
     export BUCKET_NAME=BUCKET_NAME
     export CONTROL_PLANE_LOCATION=CONTROL_PLANE_LOCATION
     export NODE_LOCATION=NODE_LOCATION
     export CLUSTER_VERSION=CLUSTER_VERSION
     

     Substitua os seguintes valores:

     • PROJECT_ID: o seu Google Cloud ID do projeto.
     • CLUSTER_NAME: o nome do seu cluster do GKE.
     • BUCKET_NAME: o nome do seu contentor do Cloud Storage. Não precisa de especificar o prefixo gs://.
     • CONTROL_PLANE_LOCATION: a região do Compute Engine do plano de controlo do seu cluster. Esta região tem de conter zonas onde os tipos de máquinas TPU v5e estão disponíveis (por exemplo, us-west1, us-west4, us-central1, us-east1, us-east5 ou europe-west4). Para clusters do Autopilot, certifique-se de que tem recursos zonais de TPU v5e suficientes para a região escolhida.
     • (Apenas para o cluster padrão) NODE_LOCATION: a zona onde os recursos de TPU estão disponíveis (por exemplo, us-west4-a). Para clusters do Autopilot, não precisa de especificar este valor.
     • CLUSTER_VERSION: a versão do GKE, que tem de suportar o tipo de máquina que quer usar. Tenha em atenção que a versão predefinida do GKE pode não ter disponibilidade para a TPU de destino. Para ver uma lista das versões mínimas do GKE disponíveis por tipo de máquina TPU, consulte o artigo Disponibilidade de TPUs no GKE.

  Crie e configure Google Cloud recursos

  Siga estas instruções para criar os recursos necessários.

  Nota: pode ter de criar uma reserva de capacidade para a utilização de alguns aceleradores. Para saber como reservar e consumir recursos reservados, consulte o artigo Consumir recursos zonais reservados.

  Crie um cluster do GKE

  Pode publicar o Gemma em TPUs 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} \
    --cluster-version=${CLUSTER_VERSION}
  

  Standard

  1. Crie um cluster padrão do GKE regional que use a Workload Identity Federation para o GKE.

     gcloud container clusters create ${CLUSTER_NAME} \
         --enable-ip-alias \
         --machine-type=e2-standard-4 \
         --num-nodes=2 \
         --cluster-version=${CLUSTER_VERSION} \
         --workload-pool=${PROJECT_ID}.svc.id.goog \
         --location=${CONTROL_PLANE_LOCATION}
     

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

  2. Execute o seguinte comando para criar um node pool para o cluster:

     gcloud container node-pools create gemma-7b-tpu-nodepool \
       --cluster=${CLUSTER_NAME} \
       --machine-type=ct5lp-hightpu-8t \
       --project=${PROJECT_ID} \
       --num-nodes=2 \
       --location=${CONTROL_PLANE_LOCATION} \
       --node-locations=${NODE_LOCATION}
     

     O GKE cria um node pool de TPUs v5e com uma 2x4topologia e dois nós.

  Crie um contentor do Cloud Storage

  No Cloud Shell, execute o seguinte comando:

  gcloud storage buckets create gs://${BUCKET_NAME} --location=${CONTROL_PLANE_LOCATION}
  

  Isto cria um contentor do Cloud Storage para armazenar os ficheiros do modelo que transferir do Kaggle.

  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 credenciais da Kaggle

  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 Secret para armazenar as credenciais do Kaggle:

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

  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. Crie uma conta de serviço do IAM para a sua aplicação:

     gcloud iam service-accounts create wi-jetstream
     

  2. Adicione uma associação de políticas do IAM para a sua conta de serviço do IAM para gerir o Cloud Storage:

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

  3. 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-jetstream@${PROJECT_ID}.iam.gserviceaccount.com \
         --role roles/iam.workloadIdentityUser \
         --member "serviceAccount:${PROJECT_ID}.svc.id.goog[default/default]"
     

  4. 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-jetstream@${PROJECT_ID}.iam.gserviceaccount.com
     

  Converta os controlos de segurança do modelo

  Nesta secção, cria uma tarefa para fazer o seguinte:

  1. Transfira o ponto de verificação base do Orbax a partir do Kaggle.
  2. Carregue o ponto de verificação para um contentor do Cloud Storage.
  3. Converta o controlo de segurança num controlo de segurança compatível com o MaxText.
  4. Desanalise o ponto de controlo a ser usado para a publicação.

  Implemente a tarefa de conversão do ponto de verificação do modelo

  Siga estas instruções para transferir e converter os ficheiros de ponto de verificação do modelo Gemma 7B. Este tutorial usa uma tarefa do Kubernetes. Um controlador de tarefas no Kubernetes cria um ou mais pods e garante que executam com êxito uma tarefa específica.

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

     apiVersion: batch/v1
     kind: Job
     metadata:
       name: data-loader-7b
     spec:
       ttlSecondsAfterFinished: 30
       template:
         spec:
           restartPolicy: Never
           containers:
           - name: inference-checkpoint
             image: us-docker.pkg.dev/cloud-tpu-images/inference/inference-checkpoint:v0.2.4
             args:
             - -b=BUCKET_NAME
             - -m=google/gemma/maxtext/7b-it/2
             volumeMounts:
             - mountPath: "/kaggle/"
               name: kaggle-credentials
               readOnly: true
             resources:
               requests:
                 google.com/tpu: 8
               limits:
                 google.com/tpu: 8
           nodeSelector:
             cloud.google.com/gke-tpu-topology: 2x4
             cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
           volumes:
           - name: kaggle-credentials
             secret:
               defaultMode: 0400
               secretName: kaggle-secret
     

  2. Aplique o manifesto:

     kubectl apply -f job-7b.yaml
     

  3. Aguarde que o pod que agendou a tarefa comece a ser executado:

     kubectl get pod -w
     

     O resultado será semelhante ao seguinte. Este processo pode demorar alguns minutos:

     NAME                  READY   STATUS              RESTARTS   AGE
     data-loader-7b-abcd   0/1     ContainerCreating   0          28s
     data-loader-7b-abcd   1/1     Running             0          51s
     

     Para clusters do Autopilot, o aprovisionamento dos recursos de TPU necessários pode demorar alguns minutos.

  4. Veja os registos do trabalho:

     kubectl logs -f jobs/data-loader-7b
     

     Quando a tarefa estiver concluída, o resultado é semelhante ao seguinte:

     Successfully generated decode checkpoint at: gs://BUCKET_NAME/final/unscanned/gemma_7b-it/0/checkpoints/0/items
     + echo -e '\nCompleted unscanning checkpoint to gs://BUCKET_NAME/final/unscanned/gemma_7b-it/0/checkpoints/0/items'
     
     Completed unscanning checkpoint to gs://BUCKET_NAME/final/unscanned/gemma_7b-it/0/checkpoints/0/items
     

  Implemente o JetStream

  Nesta secção, implementa o contentor JetStream para publicar o modelo Gemma.

  Siga estas instruções para implementar o modelo otimizado para instruções Gemma 7B. Este tutorial usa uma 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.

  1. Guarde o seguinte manifesto de implementação como jetstream-gemma-deployment.yaml:

     apiVersion: apps/v1
     kind: Deployment
     metadata:
       name: maxengine-server
     spec:
       replicas: 1
       selector:
         matchLabels:
           app: maxengine-server
       template:
         metadata:
           labels:
             app: maxengine-server
         spec:
           nodeSelector:
             cloud.google.com/gke-tpu-topology: 2x4
             cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
           containers:
           - name: maxengine-server
             image: us-docker.pkg.dev/cloud-tpu-images/inference/maxengine-server:v0.2.2
             args:
             - model_name=gemma-7b
             - tokenizer_path=assets/tokenizer.gemma
             - per_device_batch_size=4
             - max_prefill_predict_length=1024
             - max_target_length=2048
             - async_checkpointing=false
             - ici_fsdp_parallelism=1
             - ici_autoregressive_parallelism=-1
             - ici_tensor_parallelism=1
             - scan_layers=false
             - weight_dtype=bfloat16
             - load_parameters_path=gs://BUCKET_NAME/final/unscanned/gemma_7b-it/0/checkpoints/0/items
             - prometheus_port=PROMETHEUS_PORT
             ports:
             - containerPort: 9000
             resources:
               requests:
                 google.com/tpu: 8
               limits:
                 google.com/tpu: 8
           - name: jetstream-http
             image: us-docker.pkg.dev/cloud-tpu-images/inference/jetstream-http:v0.2.2
             ports:
             - containerPort: 8000
     ---
     apiVersion: v1
     kind: Service
     metadata:
       name: jetstream-svc
     spec:
       selector:
         app: maxengine-server
       ports:
       - protocol: TCP
         name: jetstream-http
         port: 8000
         targetPort: 8000
       - protocol: TCP
         name: jetstream-grpc
         port: 9000
         targetPort: 9000
     

     O manifesto define as seguintes propriedades principais:

     • tokenizer_path: o caminho para o tokenizador do seu modelo.
     • load_parameters_path: o caminho no contentor do Cloud Storage onde os seus pontos de verificação estão armazenados.
     • per_device_batch_size: o tamanho do lote de descodificação por dispositivo, em que um chip de TPU equivale a um dispositivo.
     • max_prefill_predict_length: o comprimento máximo para o preenchimento automático ao fazer a autorregressão.
     • max_target_length: o comprimento máximo da sequência.
     • model_name: o nome do modelo (gemma-7b).
     • ici_fsdp_parallelism: o número de fragmentos para paralelismo de dados totalmente fragmentados (FSDP).
     • ici_tensor_parallelism: o número de fragmentos para paralelismo de tensores.
     • ici_autoregressive_parallelism: o número de fragmentos para paralelismo autorregressivo.
     • prometheus_port: porta para expor métricas do Prometheus. Remova este argumento se não forem necessárias métricas.
     • scan_layers: sinalizador booleano de camadas de análise (booleano).
     • weight_dtype: o tipo de dados de peso (bfloat16).

  2. Aplique o manifesto:

     kubectl apply -f jetstream-gemma-deployment.yaml
     

  3. Valide a implementação:

     kubectl get deployment
     

     O resultado é semelhante ao seguinte:

     NAME                              READY   UP-TO-DATE   AVAILABLE   AGE
     maxengine-server                  2/2     2            2           ##s
     

     Para clusters do Autopilot, o aprovisionamento dos recursos de TPU necessários pode demorar alguns minutos.

  4. Veja os registos do servidor HTTP para verificar se o modelo foi carregado e compilado. O servidor pode demorar alguns minutos a concluir esta operação.

     kubectl logs deploy/maxengine-server -f -c jetstream-http
     

     O resultado é semelhante ao seguinte:

     kubectl logs deploy/maxengine-server -f -c jetstream-http
     
     INFO:     Started server process [1]
     INFO:     Waiting for application startup.
     INFO:     Application startup complete.
     INFO:     Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C to quit)
     

  5. Veja os registos do MaxEngine e verifique se a compilação está concluída.

     kubectl logs deploy/maxengine-server -f -c maxengine-server
     

     O resultado é semelhante ao seguinte:

     2024-03-29 17:09:08,047 - jax._src.dispatch - DEBUG - Finished XLA compilation of jit(initialize) in 0.26236414909362793 sec
     2024-03-29 17:09:08,150 - root - INFO - ---------Generate params 0 loaded.---------
     

  Publique o modelo

  Nesta secção, interage com o modelo.

  Configure o encaminhamento de portas

  Pode aceder à implementação do JetStream através do serviço ClusterIP que criou no passo anterior. 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:

  Para estabelecer uma sessão de encaminhamento de portas, execute o seguinte comando:

  kubectl port-forward svc/jetstream-svc 8000:8000
  

  Êxito: publicou o Gemma com êxito através de TPUs no GKE com o JetStream. Agora, pode interagir com o modelo.

  Interaja com o modelo através do curl

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

     curl --request POST \
     --header "Content-type: application/json" \
     -s \
     localhost:8000/generate \
     --data \
     '{
         "prompt": "What are the top 5 programming languages",
         "max_tokens": 200
     }'
     

     O pedido inicial pode demorar vários segundos a ser concluído devido ao aquecimento do modelo. O resultado é semelhante ao seguinte:

     {
         "response": "\nfor data science in 2023?\n\n**1. Python:**\n- Widely used for data science due to its simplicity, readability, and extensive libraries for data wrangling, analysis, visualization, and machine learning.\n- Popular libraries include pandas, scikit-learn, and matplotlib.\n\n**2. R:**\n- Statistical programming language widely used for data analysis, visualization, and modeling.\n- Popular libraries include ggplot2, dplyr, and caret.\n\n**3. Java:**\n- Enterprise-grade language with strong performance and scalability.\n- Popular libraries include Spark, TensorFlow, and Weka.\n\n**4. C++:**\n- High-performance language often used for data analytics and machine learning models.\n- Popular libraries include TensorFlow, PyTorch, and OpenCV.\n\n**5. SQL:**\n- Relational database language essential for data wrangling and querying large datasets.\n- Popular tools"
     }
     

  (Opcional) Interagir com o modelo através de uma interface de chat do Gradio

  Nesta secção, cria uma aplicação de chat Web que lhe permite interagir com o seu modelo otimizado para instruções.

  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.3
             resources:
               requests:
                 cpu: "512m"
                 memory: "512Mi"
               limits:
                 cpu: "1"
                 memory: "512Mi"
             env:
             - name: CONTEXT_PATH
               value: "/generate"
             - name: HOST
               value: "http://jetstream-svc:8000"
             - name: LLM_ENGINE
               value: "max"
             - 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 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

  • 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 os seguintes comandos e siga as instruções:

  gcloud container clusters delete ${CLUSTER_NAME} --location=${CONTROL_PLANE_LOCATION}
  
  gcloud iam service-accounts delete wi-jetstream@PROJECT_ID.iam.gserviceaccount.com
  
  gcloud storage rm --recursive gs://BUCKET_NAME
  

  O que se segue?

  • Descubra como pode executar modelos Gemma no GKE e como executar cargas de trabalho de IA/ML otimizadas com as capacidades de orquestração da plataforma GKE.
  • Saiba mais acerca das TPUs no GKE.
  • Explore o repositório do GitHub do JetStream.
  • Explore o Vertex AI Model Garden.