Publique LLMs escaláveis no GKE com o TorchServe

Autopilot

Este tutorial mostra como implementar e apresentar um modelo de aprendizagem automática (ML) escalável num cluster do Google Kubernetes Engine (GKE) através da estrutura TorchServe. Publica um modelo do PyTorch pré-preparado que gera previsões com base nas solicitações dos utilizadores. Depois de implementar o modelo, recebe um URL de previsão que a sua aplicação usa para enviar pedidos de previsão. Este método permite-lhe dimensionar o modelo e a aplicação Web de forma independente. Quando implementa a carga de trabalho e a aplicação de ML no Autopilot, o GKE escolhe o tipo e o tamanho de máquina subjacentes mais eficientes para executar as cargas de trabalho.

Este tutorial destina-se a engenheiros de aprendizagem automática (AA), administradores e operadores de plataformas, e a especialistas em dados e IA interessados em usar o GKE Autopilot para reduzir os custos administrativos relativos à configuração, ao dimensionamento e às atualizações de nós. 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 de utilizadores do GKE.

Antes de ler esta página, certifique-se de que conhece o modo Autopilot do GKE.

Acerca da aplicação do tutorial

A aplicação é uma pequena aplicação Web Python criada com o framework Fast Dash. Usa a aplicação para enviar pedidos de previsão ao modelo T5. Esta aplicação captura as entradas de texto do utilizador e os pares de idiomas, e envia as informações para o modelo. O modelo traduz o texto e devolve o resultado à aplicação, que apresenta o resultado ao utilizador. Para mais informações acerca do Fast Dash, consulte a documentação do Fast Dash.

Objetivos

• Prepare um modelo T5 pré-preparado do repositório Hugging Face para publicação, empacotando-o como uma imagem de contentor e enviando-o para o Artifact Registry
• Implemente o modelo num cluster do Autopilot
• Implemente a aplicação Fast Dash que comunica com o modelo
• Crie uma escala automática do modelo com base nas métricas do Prometheus

Custos

Neste documento, usa os seguintes componentes faturáveis do Google Cloud:

• GKE Autopilot mode
• Artifact Registry
• Cloud Storage
• Cloud Build

Para gerar uma estimativa de custos com base na sua utilização prevista, use a calculadora de preços.

Os novos Google Cloud utilizadores podem ser elegíveis para uma avaliação gratuita.

Quando terminar as tarefas descritas neste documento, pode evitar a faturação contínua eliminando os recursos que criou. Para mais informações, consulte o artigo Limpe.

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.

Install the Google Cloud CLI.

Nota: se instalou a CLI gcloud anteriormente, certifique-se de que tem a versão mais recente executando gcloud components update.

Se estiver a usar um fornecedor de identidade (IdP) externo, tem primeiro de iniciar sessão na CLI gcloud com a sua identidade federada.

Para inicializar a CLI gcloud, execute o seguinte comando:

gcloud init

Create or select 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 role (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.

• Create a Google Cloud project:

  gcloud projects create PROJECT_ID

  Replace PROJECT_ID with a name for the Google Cloud project you are creating.

• Select the Google Cloud project that you created:

  gcloud config set project PROJECT_ID

  Replace PROJECT_ID with your Google Cloud project name.

Verify that billing is enabled for your Google Cloud project.

Enable the Kubernetes Engine, Cloud Storage, Artifact Registry, and Cloud Build APIs:

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.

gcloud services enable container.googleapis.com storage.googleapis.com artifactregistry.googleapis.com cloudbuild.googleapis.com

Install the Google Cloud CLI.

Nota: se instalou a CLI gcloud anteriormente, certifique-se de que tem a versão mais recente executando gcloud components update.

Se estiver a usar um fornecedor de identidade (IdP) externo, tem primeiro de iniciar sessão na CLI gcloud com a sua identidade federada.

Para inicializar a CLI gcloud, execute o seguinte comando:

gcloud init

Create or select 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 role (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.

• Create a Google Cloud project:

  gcloud projects create PROJECT_ID

  Replace PROJECT_ID with a name for the Google Cloud project you are creating.

• Select the Google Cloud project that you created:

  gcloud config set project PROJECT_ID

  Replace PROJECT_ID with your Google Cloud project name.

Verify that billing is enabled for your Google Cloud project.

Enable the Kubernetes Engine, Cloud Storage, Artifact Registry, and Cloud Build APIs:

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.

gcloud services enable container.googleapis.com storage.googleapis.com artifactregistry.googleapis.com cloudbuild.googleapis.com

Prepare o ambiente

Clone o repositório de exemplo e abra o diretório do tutorial:

git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples.git
cd kubernetes-engine-samples/ai-ml/t5-model-serving

Crie o cluster

Execute o seguinte comando:

gcloud container clusters create-auto ml-cluster \
    --release-channel=RELEASE_CHANNEL \
    --cluster-version=CLUSTER_VERSION \
    --location=us-central1

Substitua o seguinte:

• RELEASE_CHANNEL: o canal de lançamento do seu cluster. Tem de ser um de rapid, regular ou stable. Escolha um canal com a versão 1.28.3-gke.1203000 ou posterior do GKE para usar GPUs L4. Para ver as versões disponíveis num canal específico, consulte o artigo Veja as versões predefinidas e disponíveis para canais de lançamento.
• CLUSTER_VERSION: a versão do GKE a usar. Tem de ser 1.28.3-gke.1203000 ou posterior.

Esta operação demora vários minutos a ser concluída.

Crie um repositório do Artifact Registry

1. Crie um novo repositório padrão do Artifact Registry com o formato Docker na mesma região que o seu cluster:

   gcloud artifacts repositories create models \
       --repository-format=docker \
       --location=us-central1 \
       --description="Repo for T5 serving image"
   

2. Valide o nome do repositório:

   gcloud artifacts repositories describe models \
       --location=us-central1
   

   O resultado é semelhante ao seguinte:

   Encryption: Google-managed key
   Repository Size: 0.000MB
   createTime: '2023-06-14T15:48:35.267196Z'
   description: Repo for T5 serving image
   format: DOCKER
   mode: STANDARD_REPOSITORY
   name: projects/PROJECT_ID/locations/us-central1/repositories/models
   updateTime: '2023-06-14T15:48:35.267196Z'
   

Empacote o modelo

Nesta secção, vai criar um pacote do modelo e da framework de publicação numa única imagem de contentor com o Cloud Build e enviar a imagem resultante para o repositório do Artifact Registry.

1. Reveja o Dockerfile da imagem de contentor:

   # Copyright 2023 Google LLC
   #
   # Licensed under the Apache License, Version 2.0 (the "License");
   # you may not use this file except in compliance with the License.
   # You may obtain a copy of the License at
   #
   #     https://www.apache.org/licenses/LICENSE-2.0
   #
   # Unless required by applicable law or agreed to in writing, software
   # distributed under the License is distributed on an "AS IS" BASIS,
   # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   # See the License for the specific language governing permissions and
   # limitations under the License.
   
   ARG BASE_IMAGE=pytorch/torchserve:0.12.0-cpu
   
   FROM alpine/git
   
   ARG MODEL_NAME=t5-small
   ARG MODEL_REPO=https://huggingface.co/${MODEL_NAME}
   ENV MODEL_NAME=${MODEL_NAME}
   ENV MODEL_VERSION=${MODEL_VERSION}
   
   RUN git clone "${MODEL_REPO}" /model
   
   FROM ${BASE_IMAGE}
   
   ARG MODEL_NAME=t5-small
   ARG MODEL_VERSION=1.0
   ENV MODEL_NAME=${MODEL_NAME}
   ENV MODEL_VERSION=${MODEL_VERSION}
   
   COPY --from=0 /model/. /home/model-server/
   COPY handler.py \
        model.py \
        requirements.txt \
        setup_config.json /home/model-server/
   
   RUN  torch-model-archiver \
        --model-name="${MODEL_NAME}" \
        --version="${MODEL_VERSION}" \
        --model-file="model.py" \
        --serialized-file="pytorch_model.bin" \
        --handler="handler.py" \
        --extra-files="config.json,spiece.model,tokenizer.json,setup_config.json" \
        --runtime="python" \
        --export-path="model-store" \
        --requirements-file="requirements.txt"
   
   FROM ${BASE_IMAGE}
   
   ENV PATH /home/model-server/.local/bin:$PATH
   ENV TS_CONFIG_FILE /home/model-server/config.properties
   # CPU inference will throw a warning cuda warning (not error)
   # Could not load dynamic library 'libnvinfer_plugin.so.7'
   # This is expected behaviour. see: https://stackoverflow.com/a/61137388
   ENV TF_CPP_MIN_LOG_LEVEL 2
   
   COPY --from=1 /home/model-server/model-store/ /home/model-server/model-store
   COPY config.properties /home/model-server/
   

   Este Dockerfile define o seguinte processo de compilação de várias fases:

   1. Transfira os artefactos do modelo do repositório do Hugging Face.
   2. Empacote o modelo com a ferramenta PyTorch Serving Archive. Isto cria um ficheiro de arquivo do modelo (.mar) que o servidor de inferência usa para carregar o modelo.
   3. Crie a imagem final com o PyTorch Serve.

2. Crie e envie a imagem através do Cloud Build:

   gcloud builds submit model/ \
       --region=us-central1 \
       --config=model/cloudbuild.yaml \
       --substitutions=_LOCATION=us-central1,_MACHINE=gpu,_MODEL_NAME=t5-small,_MODEL_VERSION=1.0
   

   O processo de compilação demora vários minutos a ser concluído. Se usar um tamanho do modelo superior a t5-small, o processo de compilação pode demorar significativamente mais tempo.

3. Verifique se a imagem está no repositório:

   gcloud artifacts docker images list us-central1-docker.pkg.dev/PROJECT_ID/models
   

   Substitua PROJECT_ID pelo seu Google Cloud ID do projeto.

   O resultado é semelhante ao seguinte:

   IMAGE                                                     DIGEST         CREATE_TIME          UPDATE_TIME
   us-central1-docker.pkg.dev/PROJECT_ID/models/t5-small     sha256:0cd...  2023-06-14T12:06:38  2023-06-14T12:06:38
   

Implemente o modelo em pacote no GKE

Para implementar a imagem, 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ídos entre os nós num cluster.

Modifique o manifesto do Kubernetes no repositório de exemplo para corresponder ao seu ambiente.

1. Reveja o manifesto da carga de trabalho de inferência:

   # Copyright 2023 Google LLC
   #
   # Licensed under the Apache License, Version 2.0 (the "License");
   # you may not use this file except in compliance with the License.
   # You may obtain a copy of the License at
   #
   #     https://www.apache.org/licenses/LICENSE-2.0
   #
   # Unless required by applicable law or agreed to in writing, software
   # distributed under the License is distributed on an "AS IS" BASIS,
   # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   # See the License for the specific language governing permissions and
   # limitations under the License.
   
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: t5-inference
     labels:
       model: t5
       version: v1.0
       machine: gpu
   spec:
     replicas: 1
     selector:
       matchLabels:
         model: t5
         version: v1.0
         machine: gpu
     template:
       metadata:
         labels:
           model: t5
           version: v1.0
           machine: gpu
       spec:
         nodeSelector:
           cloud.google.com/gke-accelerator: nvidia-l4
         securityContext:
           fsGroup: 1000
           runAsUser: 1000
           runAsGroup: 1000
         containers:
           - name: inference
             image: us-central1-docker.pkg.dev/PROJECT_ID/models/t5-small:1.0-gpu
             imagePullPolicy: IfNotPresent
             args: ["torchserve", "--start", "--foreground"]
             resources:
               limits:
                 nvidia.com/gpu: "1"
                 cpu: "3000m"
                 memory: 16Gi
                 ephemeral-storage: 10Gi
               requests:
                 nvidia.com/gpu: "1"
                 cpu: "3000m"
                 memory: 16Gi
                 ephemeral-storage: 10Gi
             ports:
               - containerPort: 8080
                 name: http
               - containerPort: 8081
                 name: management
               - containerPort: 8082
                 name: metrics
             readinessProbe:
               httpGet:
                 path: /ping
                 port: http
               initialDelaySeconds: 120
               failureThreshold: 10
             livenessProbe:
               httpGet:
                 path: /models/t5-small
                 port: management
               initialDelaySeconds: 150
               periodSeconds: 5
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: t5-inference
     labels:
       model: t5
       version: v1.0
       machine: gpu
   spec:
     type: ClusterIP
     selector:
       model: t5
       version: v1.0
       machine: gpu
     ports:
       - port: 8080
         name: http
         targetPort: http
       - port: 8081
         name: management
         targetPort: management
       - port: 8082
         name: metrics
         targetPort: metrics
   

2. Substitua PROJECT_ID pelo seu Google Cloud ID do projeto:

   sed -i "s/PROJECT_ID/PROJECT_ID/g" "kubernetes/serving-gpu.yaml"
   

   Isto garante que o caminho da imagem do contentor na especificação de implementação corresponde ao caminho da imagem do modelo T5 no Artifact Registry.

3. Crie os recursos do Kubernetes:

   kubectl create -f kubernetes/serving-gpu.yaml
   

Para verificar se o modelo foi implementado com êxito, faça o seguinte:

1. Obtenha o estado da implementação e do serviço:

   kubectl get -f kubernetes/serving-gpu.yaml
   

   Aguarde até que o resultado mostre Pods prontos, semelhantes ao seguinte. Consoante o tamanho da imagem, a primeira obtenção de imagens pode demorar vários minutos.

   NAME                            READY   UP-TO-DATE    AVAILABLE   AGE
   deployment.apps/t5-inference    1/1     1             0           66s
   
   NAME                    TYPE        CLUSTER-IP        EXTERNAL-IP   PORT(S)                       AGE
   service/t5-inference    ClusterIP   10.48.131.86    <none>        8080/TCP,8081/TCP,8082/TCP    66s
   

2. Abra uma porta local para o t5-inference serviço:

   kubectl port-forward svc/t5-inference 8080
   

3. Abra uma nova janela de terminal e envie um pedido de teste ao serviço:

   curl -v -X POST -H 'Content-Type: application/json' -d '{"text": "this is a test sentence", "from": "en", "to": "fr"}' "http://localhost:8080/predictions/t5-small/1.0"
   

   Se o pedido de teste falhar e a ligação do Pod for fechada, verifique os registos:

   kubectl logs deployments/t5-inference
   

   Se o resultado for semelhante ao seguinte, o TorchServe não conseguiu instalar algumas dependências do modelo:

   org.pytorch.serve.archive.model.ModelException: Custom pip package installation failed for t5-small
   

   Para resolver este problema, reinicie a implementação:

   kubectl rollout restart deployment t5-inference
   

   O controlador de implementação cria um novo pod. Repita os passos anteriores para abrir uma porta no novo Pod.

Aceda ao modelo implementado através da aplicação Web

Para aceder ao modelo implementado com a aplicação Web Fast Dash, conclua os seguintes passos:

1. Crie e envie a app Web Fast Dash como uma imagem de contentor no Artifact Registry:

   gcloud builds submit client-app/ \
       --region=us-central1 \
       --config=client-app/cloudbuild.yaml
   

2. Abra kubernetes/application.yaml num editor de texto e substitua PROJECT_ID no campo image: pelo ID do seu projeto. Em alternativa, execute o seguinte comando:

   sed -i "s/PROJECT_ID/PROJECT_ID/g" "kubernetes/application.yaml"
   

3. Crie os recursos do Kubernetes:

   kubectl create -f kubernetes/application.yaml
   

   A implementação e o serviço podem demorar algum tempo a serem totalmente aprovisionados.

4. Para verificar o estado, execute o seguinte comando:

   kubectl get -f kubernetes/application.yaml
   

   Aguarde até que o resultado mostre Pods prontos, semelhante ao seguinte:

   NAME                       READY   UP-TO-DATE   AVAILABLE   AGE
   deployment.apps/fastdash   1/1     1            0           1m
   
   NAME               TYPE       CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE
   service/fastdash   NodePort   203.0.113.12    <none>        8050/TCP         1m
   

5. A aplicação Web está agora em execução, embora não esteja exposta num endereço IP externo. Para aceder à aplicação Web, abra uma porta local:

   kubectl port-forward service/fastdash 8050
   

6. Num navegador, abra a interface Web:

   • Se estiver a usar uma shell local, abra um navegador e aceda a http://127.0.0.1:8050.
   • Se estiver a usar o Cloud Shell, clique em Pré-visualização Web e, de seguida, em Alterar porta. Especifique a porta 8050.

7. Para enviar um pedido ao modelo T5, especifique valores nos campos TEXT, FROM LANG e TO LANG na interface Web e clique em Enviar. Para ver uma lista dos idiomas disponíveis, consulte a documentação do T5.

Ative o dimensionamento automático para o modelo

Esta secção mostra como ativar o dimensionamento automático para o modelo com base nas métricas do Google Cloud Managed Service for Prometheus fazendo o seguinte:

1. Instale o adaptador do Stackdriver de métricas personalizadas
2. Aplique configurações de PodMonitoring e HorizontalPodAutoscaling

O Google Cloud Managed Service for Prometheus está ativado por predefinição em clusters do Autopilot com a versão 1.25 e posteriores.

Instale o adaptador do Stackdriver de métricas personalizadas

Este adaptador permite que o cluster use métricas do Prometheus para tomar decisões de ajuste de escala automático do Kubernetes.

1. Implemente o adaptador:

   kubectl create -f https://raw.githubusercontent.com/GoogleCloudPlatform/k8s-stackdriver/master/custom-metrics-stackdriver-adapter/deploy/production/adapter_new_resource_model.yaml
   

2. Crie uma conta de serviço do IAM para o adaptador usar:

   gcloud iam service-accounts create monitoring-viewer
   

3. Conceda à conta de serviço de IAM a função monitoring.viewer no projeto e a função iam.workloadIdentityUser:

   gcloud projects add-iam-policy-binding PROJECT_ID \
       --member "serviceAccount:monitoring-viewer@PROJECT_ID.iam.gserviceaccount.com" \
       --role roles/monitoring.viewer
   gcloud iam service-accounts add-iam-policy-binding monitoring-viewer@PROJECT_ID.iam.gserviceaccount.com \
       --role roles/iam.workloadIdentityUser \
       --member "serviceAccount:PROJECT_ID.svc.id.goog[custom-metrics/custom-metrics-stackdriver-adapter]"
   

   Substitua PROJECT_ID pelo seu Google Cloud ID do projeto.

4. Anote a conta de serviço do Kubernetes do adaptador para lhe permitir roubar a identidade da conta de serviço do IAM:

   kubectl annotate serviceaccount custom-metrics-stackdriver-adapter \
       --namespace custom-metrics \
       iam.gke.io/gcp-service-account=monitoring-viewer@PROJECT_ID.iam.gserviceaccount.com
   

5. Reinicie o adaptador para propagar as alterações:

   kubectl rollout restart deployment custom-metrics-stackdriver-adapter \
       --namespace=custom-metrics
   

Aplique configurações de PodMonitoring e HorizontalPodAutoscaling

O PodMonitoring é um recurso personalizado do Google Cloud Managed Service for Prometheus que permite a ingestão de métricas e a recolha de alvos num espaço de nomes específico.

1. Implemente o recurso PodMonitoring no mesmo espaço de nomes que a implementação do TorchServe:

   kubectl apply -f kubernetes/pod-monitoring.yaml
   

2. Reveja o manifesto HorizontalPodAutoscaler:

   # Copyright 2023 Google LLC
   #
   # Licensed under the Apache License, Version 2.0 (the "License");
   # you may not use this file except in compliance with the License.
   # You may obtain a copy of the License at
   #
   #     https://www.apache.org/licenses/LICENSE-2.0
   #
   # Unless required by applicable law or agreed to in writing, software
   # distributed under the License is distributed on an "AS IS" BASIS,
   # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   # See the License for the specific language governing permissions and
   # limitations under the License.
   
   apiVersion: autoscaling/v2
   kind: HorizontalPodAutoscaler
   metadata:
     name: t5-inference
   spec:
     scaleTargetRef:
       apiVersion: apps/v1
       kind: Deployment
       name: t5-inference
     minReplicas: 1
     maxReplicas: 5
     metrics:
     - type: Pods
       pods:
         metric:
           name: prometheus.googleapis.com|ts_queue_latency_microseconds|counter
         target:
           type: AverageValue
           averageValue: "30000"
   

   O HorizontalPodAutoscaler dimensiona a quantidade de pods do modelo T5 com base na duração cumulativa da fila de pedidos. A escala automática baseia-se na métrica ts_queue_latency_microseconds, que mostra a duração cumulativa da fila em microsegundos.

3. Crie o HorizontalPodAutoscaler:

   kubectl apply -f kubernetes/hpa.yaml
   

Valide o dimensionamento automático com um gerador de carga

Para testar a configuração do ajuste de escala automático, gere carga para a aplicação de publicação. Este tutorial usa um gerador de carga do Locust para enviar pedidos para o ponto final de previsão do modelo.

1. Crie o gerador de carga:

   kubectl apply -f kubernetes/loadgenerator.yaml
   

   Aguarde que os pods do gerador de carga fiquem prontos.

2. Exponha a interface Web do gerador de carga localmente:

   kubectl port-forward svc/loadgenerator 8080
   

   Se vir uma mensagem de erro, tente novamente quando o Pod estiver em funcionamento.

3. Num navegador, abra a interface Web do gerador de carga:

   • Se estiver a usar uma shell local, abra um navegador e aceda a http://127.0.0.1:8080.
   • Se estiver a usar o Cloud Shell, clique em Pré-visualização Web e, de seguida, clique em Alterar porta. Introduza a porta 8080.

4. Clique no separador Gráficos para observar o desempenho ao longo do tempo.

5. Abra uma nova janela de terminal e monitorize a contagem de réplicas dos seus redimensionadores automáticos de pods horizontais:

   kubectl get hpa -w
   

   O número de réplicas aumenta à medida que a carga aumenta. O aumento da escala pode demorar cerca de dez minutos. À medida que são iniciadas novas réplicas, o número de pedidos bem-sucedidos no gráfico do Locust aumenta.

   NAME           REFERENCE                 TARGETS           MINPODS   MAXPODS   REPLICAS   AGE
   t5-inference   Deployment/t5-inference   71352001470m/7M   1         5        1           2m11s
   

Nota: a framework Locust reutiliza as ligações abertas, pelo que não pode ver alterações num gráfico após um evento de expansão. No entanto, pode parar uma execução atual do gerador de carga clicando em Parar e, em seguida, iniciar um novo teste de geração de carga para observar o aumento nos pedidos por segundo.

Recomendações

• Crie o modelo com a mesma versão da imagem Docker base que vai usar para a publicação.
• Se o seu modelo tiver dependências de pacotes especiais ou se o tamanho das dependências for grande, crie uma versão personalizada da sua imagem Docker base.
• Monitorize a versão de árvore dos pacotes de dependências do modelo. Certifique-se de que as dependências dos pacotes suportam as versões umas das outras. Por exemplo, a versão 2.0.3 do Panda suporta a versão 1.20.3 e posteriores do NumPy.
• Execute modelos com utilização intensiva da GPU em nós de GPU e modelos com utilização intensiva da CPU na CPU. Isto pode melhorar a estabilidade da publicação de modelos e garante que está a consumir recursos de nós de forma eficiente.

Observe o desempenho do modelo

Para observar o desempenho do modelo, pode usar a integração do painel de controlo do TorchServe 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 do TorchServe, tem de ativar o Google Cloud Managed Service for Prometheus, que recolhe as métricas do TorchServe, no seu cluster do GKE. O TorchServe expõe métricas no formato Prometheus por predefinição; não precisa de instalar um exportador adicional.

Em seguida, pode ver as métricas através do painel de controlo do TorchServe. Para obter informações sobre como usar o Google Cloud Managed Service for Prometheus para recolher métricas do seu modelo, consulte as orientações de observabilidade do TorchServe na documentação do Cloud Monitoring.

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 o projeto

Atenção: a eliminação de um projeto tem os seguintes efeitos:

• Tudo no projeto é eliminado. Se usou um projeto existente para as tarefas neste documento, quando o elimina, também elimina qualquer outro trabalho que tenha feito no projeto.
• Os IDs dos projetos personalizados são perdidos. Quando criou este projeto, pode ter criado um ID do projeto personalizado que quer usar no futuro. Para preservar os URLs que usam o ID do projeto, como um URL appspot.com, elimine os recursos selecionados no projeto em vez de eliminar o projeto inteiro.

Se planeia explorar várias arquiteturas, tutoriais ou inícios rápidos, a reutilização de projetos pode ajudar a evitar exceder os limites de quota de projetos.

Delete a Google Cloud project:

gcloud projects delete PROJECT_ID

Elimine recursos individuais

1. Elimine os recursos do Kubernetes:

   kubectl delete -f kubernetes/loadgenerator.yaml
   kubectl delete -f kubernetes/hpa.yaml
   kubectl delete -f kubernetes/pod-monitoring.yaml
   kubectl delete -f kubernetes/application.yaml
   kubectl delete -f kubernetes/serving-gpu.yaml
   kubectl delete -f https://raw.githubusercontent.com/GoogleCloudPlatform/k8s-stackdriver/master/custom-metrics-stackdriver-adapter/deploy/production/adapter_new_resource_model.yaml
   

2. Elimine o cluster do GKE:

   gcloud container clusters delete "ml-cluster" \
       --location="us-central1" --quiet
   

3. Elimine a conta de serviço do IAM e as associações da política do IAM:

   gcloud projects remove-iam-policy-binding PROJECT_ID \
       --member "serviceAccount:monitoring-viewer@PROJECT_ID.iam.gserviceaccount.com" \
       --role roles/monitoring.viewer
   gcloud iam service-accounts remove-iam-policy-binding monitoring-viewer@PROJECT_ID.iam.gserviceaccount.com \
       --role roles/iam.workloadIdentityUser \
       --member "serviceAccount:PROJECT_ID.svc.id.goog[custom-metrics/custom-metrics-stackdriver-adapter]"
   gcloud iam service-accounts delete monitoring-viewer
   

4. Elimine as imagens no Artifact Registry. Opcionalmente, elimine todo o repositório. Para ver instruções, consulte a documentação do Artifact Registry sobre como eliminar imagens.

Vista geral dos componentes

Esta secção descreve os componentes usados neste tutorial, como o modelo, a aplicação Web, a framework e o cluster.

Acerca do modelo T5

Este tutorial usa um modelo T5 multilingue pré-preparado. O T5 é um transformador de texto para texto que converte texto de um idioma para outro. No T5, as entradas e as saídas são sempre strings de texto, ao contrário dos modelos de estilo BERT que só podem gerar uma etiqueta de classe ou um intervalo da entrada. O modelo T5 também pode ser usado para tarefas como resumo, perguntas e respostas ou classificação de texto. O modelo é preparado com uma grande quantidade de texto do Colossal Clean Crawled Corpus (C4) e do Wiki-DPR.

Para mais informações, consulte a documentação do modelo T5.

Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li e Peter J. Liu apresentou o modelo T5 no artigo Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer, publicado no Journal of Machine Learning Research.

O modelo T5 suporta vários tamanhos de modelos, com diferentes níveis de complexidade adequados para exemplos de utilização específicos. Este tutorial usa o tamanho predefinido, t5-small, mas também pode escolher um tamanho diferente. Os seguintes tamanhos do T5 são distribuídos ao abrigo da licença Apache 2.0:

• t5-small: 60 milhões de parâmetros
• t5-base: 220 milhões de parâmetros
• t5-large: 770 milhões de parâmetros. Transferência de 3 GB.
• t5-3b: 3 mil milhões de parâmetros. Transferência de 11 GB.
• t5-11b: 11 mil milhões de parâmetros. Transferência de 45 GB.

Para outros modelos T5 disponíveis, consulte o repositório Hugging Face.

Acerca do TorchServe

O TorchServe é uma ferramenta flexível para publicar modelos do PyTorch. Oferece suporte imediato para todas as principais frameworks de aprendizagem profunda, incluindo PyTorch, TensorFlow e ONNX. O TorchServe pode ser usado para implementar modelos em produção ou para a criação rápida de protótipos e experimentação.

O que se segue?

• Apresente um MDG com várias GPUs.
• Explore arquiteturas de referência, diagramas e práticas recomendadas sobre o Google Cloud. Consulte o nosso Centro de arquitetura na nuvem.