Servir LLMs escalables en GKE con TorchServe

Autopilot

---

En este tutorial se muestra cómo desplegar y servir un modelo de aprendizaje automático (ML) escalable en un clúster de Google Kubernetes Engine (GKE) mediante el framework TorchServe. Sirves un modelo de PyTorch preentrenado que genera predicciones basadas en las solicitudes de los usuarios. Una vez que hayas desplegado el modelo, obtendrás una URL de predicción que tu aplicación usará para enviar solicitudes de predicción. Este método te permite escalar el modelo y la aplicación web de forma independiente. Cuando despliegas la carga de trabajo y la aplicación de aprendizaje automático en Autopilot, GKE elige el tipo y el tamaño de máquina subyacentes más eficientes para ejecutar las cargas de trabajo.

Este tutorial está dirigido a ingenieros de aprendizaje automático, administradores y operadores de plataformas, y especialistas en datos e IA que estén interesados en usar GKE Autopilot para reducir la sobrecarga administrativa de la configuración, el escalado y las actualizaciones de los nodos. Para obtener más información sobre los roles habituales y las tareas de ejemplo a las que hacemos referencia en el contenido de Google Cloud , consulta Roles y tareas de usuario habituales de GKE.

Antes de leer esta página, familiarízate con el modo Autopilot de GKE.

Acerca de la aplicación del tutorial

La aplicación es una pequeña aplicación web de Python creada con el framework Fast Dash. Usa la aplicación para enviar solicitudes de predicción al modelo T5. Esta aplicación registra las entradas de texto y los pares de idiomas de los usuarios y envía la información al modelo. El modelo traduce el texto y devuelve el resultado a la aplicación, que lo muestra al usuario. Para obtener más información sobre Fast Dash, consulta la documentación de Fast Dash.

Objetivos

• Prepara un modelo T5 preentrenado del repositorio Hugging Face para servirlo. Para ello, empaquétalo como una imagen de contenedor y envíalo a Artifact Registry.
• Desplegar el modelo en un clúster de Autopilot
• Desplegar la aplicación Fast Dash que se comunica con el modelo
• Escalar automáticamente el modelo en función de las métricas de Prometheus

Costes

En este documento, se utilizan los siguientes componentes facturables de Google Cloud:

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

Para generar una estimación de costes basada en el uso previsto, utiliza la calculadora de precios.

Los usuarios nuevos Google Cloud pueden disfrutar de una prueba gratuita.

Cuando termines las tareas que se describen en este documento, puedes evitar que se te siga facturando eliminando los recursos que has creado. Para obtener más información, consulta la sección Limpiar.

Antes de empezar

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: Si ya has instalado la CLI de gcloud, asegúrate de tener la versión más reciente ejecutando gcloud components update.

Si utilizas un proveedor de identidades (IdP) externo, primero debes iniciar sesión en la CLI de gcloud con tu identidad federada.

Para inicializar gcloud CLI, ejecuta el siguiente 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 (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: Si ya has instalado la CLI de gcloud, asegúrate de tener la versión más reciente ejecutando gcloud components update.

Si utilizas un proveedor de identidades (IdP) externo, primero debes iniciar sesión en la CLI de gcloud con tu identidad federada.

Para inicializar gcloud CLI, ejecuta el siguiente 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 (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

Preparar el entorno

Clona el repositorio de ejemplo y abre el directorio del tutorial:

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

Crear el clúster

Ejecuta el siguiente comando:

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

Haz los cambios siguientes:

• RELEASE_CHANNEL: el canal de lanzamiento de tu clúster. Debe ser rapid, regular o stable. Elige un canal que tenga la versión 1.28.3-gke.1203000 de GKE o una posterior para usar las GPUs L4. Para ver las versiones disponibles en un canal específico, consulta Ver las versiones predeterminadas y disponibles de los canales de lanzamiento.
• CLUSTER_VERSION: la versión de GKE que se va a usar. Debe ser 1.28.3-gke.1203000 o posterior.

Esta operación tarda varios minutos en completarse.

Crear un repositorio de Artifact Registry

1. Crea un repositorio estándar de Artifact Registry con el formato Docker en la misma región que tu clúster:

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

2. Verifica el nombre del repositorio:

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

   El resultado debería ser similar al siguiente:

   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'
   

Empaquetar el modelo

En esta sección, empaquetarás el modelo y el framework de servicio en una sola imagen de contenedor con Cloud Build y enviarás la imagen resultante al repositorio de Artifact Registry.

1. Revisa el Dockerfile de la imagen de contenedor:

   # 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 archivo Dockerfile define el siguiente proceso de compilación de varias fases:

   1. Descarga los artefactos del modelo del repositorio de Hugging Face.
   2. Empaqueta el modelo con la herramienta PyTorch Serving Archive. De este modo, se crea un archivo de modelo (.mar) que el servidor de inferencia usa para cargar el modelo.
   3. Crea la imagen final con PyTorch Serve.

2. Crea y envía la imagen con 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
   

   El proceso de compilación tarda varios minutos en completarse. Si usas un tamaño de modelo mayor que t5-small, el proceso de compilación puede tardar mucho más.

3. Comprueba que la imagen esté en el repositorio:

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

   Sustituye PROJECT_ID por el ID de tu proyecto. Google Cloud

   El resultado debería ser similar al siguiente:

   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
   

Desplegar el modelo empaquetado en GKE

Para desplegar la imagen, en este tutorial se usan los desplegues de Kubernetes. Un Deployment es un objeto de la API de Kubernetes que te permite ejecutar varias réplicas de pods distribuidas entre los nodos de un clúster.

Modifica el manifiesto de Kubernetes del repositorio de ejemplo para que se ajuste a tu entorno.

1. Revisa el archivo de manifiesto de la carga de trabajo de inferencia:

   # 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. Sustituye PROJECT_ID por el ID de tu proyecto: Google Cloud

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

   De esta forma, se asegura de que la ruta de la imagen de contenedor en la especificación de Deployment coincida con la ruta de la imagen del modelo T5 en Artifact Registry.

3. Crea los recursos de Kubernetes:

   kubectl create -f kubernetes/serving-gpu.yaml
   

Para comprobar que el modelo se ha implementado correctamente, sigue estos pasos:

1. Obtén el estado del despliegue y del servicio:

   kubectl get -f kubernetes/serving-gpu.yaml
   

   Espera hasta que el resultado muestre pods listos, como en el siguiente ejemplo. En función del tamaño de la imagen, la primera extracción de la imagen puede tardar varios 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. Abre un puerto local para el t5-inference servicio:

   kubectl port-forward svc/t5-inference 8080
   

3. Abre una nueva ventana de terminal y envía una solicitud de prueba al servicio:

   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"
   

   Si la solicitud de prueba falla y la conexión del pod se cierra, comprueba los registros:

   kubectl logs deployments/t5-inference
   

   Si el resultado es similar al siguiente, significa que no se han podido instalar algunas dependencias del modelo de TorchServe:

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

   Para solucionar este problema, reinicia la implementación:

   kubectl rollout restart deployment t5-inference
   

   El controlador de la implementación crea un nuevo pod. Repite los pasos anteriores para abrir un puerto en el nuevo Pod.

Acceder al modelo desplegado mediante la aplicación web

Para acceder al modelo implementado con la aplicación web Fast Dash, sigue estos pasos:

1. Crea y envía la aplicación web Fast Dash como una imagen de contenedor en Artifact Registry:

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

2. Abre kubernetes/application.yaml en un editor de texto y sustituye PROJECT_ID en el campo image: por el ID de tu proyecto. También puedes ejecutar el siguiente comando:

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

3. Crea los recursos de Kubernetes:

   kubectl create -f kubernetes/application.yaml
   

   El despliegue y el servicio pueden tardar un tiempo en aprovisionarse por completo.

4. Para comprobar el estado, ejecuta el siguiente comando:

   kubectl get -f kubernetes/application.yaml
   

   Espera hasta que el resultado muestre pods listos, como en el siguiente ejemplo:

   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. La aplicación web ya se está ejecutando, aunque no se expone en una dirección IP externa. Para acceder a la aplicación web, abre un puerto local:

   kubectl port-forward service/fastdash 8050
   

6. En un navegador, abre la interfaz web:

   • Si usas un shell local, abre un navegador y ve a http://127.0.0.1:8050.
   • Si usas Cloud Shell, haz clic en Vista previa web y, a continuación, en Cambiar puerto. Especifica el puerto 8050.

7. Para enviar una solicitud al modelo T5, especifica los valores en los campos TEXT (TEXTO), FROM LANG (LENGUAJE DE ORIGEN) y TO LANG (LENGUAJE DE DESTINO) de la interfaz web y haz clic en Submit (Enviar). Para ver una lista de los idiomas disponibles, consulta la documentación de T5.

Habilitar el autoescalado del modelo

En esta sección se muestra cómo habilitar el escalado automático del modelo en función de las métricas de Google Cloud Managed Service para Prometheus. Para ello, sigue estos pasos:

1. Instalar el adaptador de Stackdriver de métricas personalizadas
2. Aplicar configuraciones de PodMonitoring y HorizontalPodAutoscaling

Google Cloud Managed Service para Prometheus está habilitado de forma predeterminada en los clústeres Autopilot que ejecutan la versión 1.25 y posteriores.

Instalar el adaptador de Stackdriver de métricas personalizadas

Este adaptador permite que tu clúster use métricas de Prometheus para tomar decisiones de escalado automático de Kubernetes.

1. Implementa el adaptador:

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

2. Crea una cuenta de servicio de IAM para que la use el adaptador:

   gcloud iam service-accounts create monitoring-viewer
   

3. Asigna a la cuenta de servicio de gestión de identidades y accesos el rol monitoring.viewer en el proyecto y el rol 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]"
   

   Sustituye PROJECT_ID por el ID de tu proyecto. Google Cloud

4. Anota la cuenta de servicio de Kubernetes del adaptador para que pueda suplantar la identidad de la cuenta de servicio de gestión de identidades y accesos:

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

5. Reinicia el adaptador para propagar los cambios:

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

Aplicar configuraciones de PodMonitoring y HorizontalPodAutoscaling

PodMonitoring es un recurso personalizado de Google Cloud Managed Service para Prometheus que permite la ingestión de métricas y el raspado de destinos en un espacio de nombres específico.

1. Despliega el recurso PodMonitoring en el mismo espacio de nombres que el Deployment de TorchServe:

   kubectl apply -f kubernetes/pod-monitoring.yaml
   

2. Revisa el manifiesto de 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"
   

   HorizontalPodAutoscaler escala la cantidad de pods del modelo T5 en función de la duración acumulada de la cola de solicitudes. El autoescalado se basa en la métrica ts_queue_latency_microseconds, que muestra la duración acumulada de la cola en microsegundos.

3. Crea el objeto HorizontalPodAutoscaler:

   kubectl apply -f kubernetes/hpa.yaml
   

Verificar el autoescalado con un generador de carga

Para probar la configuración del autoescalado, genera carga para la aplicación de servicio. En este tutorial se usa un generador de carga de Locust para enviar solicitudes al endpoint de predicción del modelo.

1. Crea el generador de carga:

   kubectl apply -f kubernetes/loadgenerator.yaml
   

   Espera a que los pods del generador de carga estén listos.

2. Expón la interfaz web del generador de carga de forma local:

   kubectl port-forward svc/loadgenerator 8080
   

   Si aparece un mensaje de error, vuelve a intentarlo cuando el Pod esté en funcionamiento.

3. En un navegador, abre la interfaz web del generador de carga:

   • Si usas una shell local, abre un navegador y ve a http://127.0.0.1:8080.
   • Si usas Cloud Shell, haz clic en Vista previa web y, a continuación, en Cambiar puerto. Introduce el puerto 8080.

4. Haga clic en la pestaña Gráficos para observar el rendimiento a lo largo del tiempo.

5. Abre una nueva ventana de terminal y observa el número de réplicas de tus escaladores automáticos de pods horizontales:

   kubectl get hpa -w
   

   El número de réplicas aumenta a medida que lo hace la carga. El escalado puede tardar unos diez minutos. A medida que se inician nuevas réplicas, aumenta el número de solicitudes correctas en el gráfico de Locust.

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

Nota: El framework de Locust reutiliza las conexiones abiertas, por lo que no verás cambios en un gráfico después de un evento de escalado vertical. Sin embargo, puedes detener la ejecución actual del generador de carga haciendo clic en Detener y, a continuación, iniciar una nueva prueba de generación de carga para observar el aumento de las solicitudes por segundo.

Recomendaciones

• Crea tu modelo con la misma versión de la imagen Docker base que usarás para el servicio.
• Si tu modelo tiene dependencias de paquetes especiales o si el tamaño de tus dependencias es grande, crea una versión personalizada de tu imagen base de Docker.
• Consulta la versión de árbol de los paquetes de dependencia de tu modelo. Asegúrate de que las dependencias de tu paquete sean compatibles entre sí. Por ejemplo, la versión 2.0.3 de Pandas es compatible con la versión 1.20.3 de NumPy y versiones posteriores.
• Ejecuta modelos que requieran mucha GPU en nodos de GPU y modelos que requieran mucha CPU en CPUs. Esto podría mejorar la estabilidad del servicio de modelos y asegurar que consumas los recursos de los nodos de forma eficiente.

Observar el rendimiento del modelo

Para observar el rendimiento del modelo, puedes usar la integración del panel de control de TorchServe en Cloud Monitoring. Con este panel de control, puede ver métricas de rendimiento críticas, como el rendimiento de tokens, la latencia de las solicitudes y las tasas de error.

Para usar el panel de control de TorchServe, debes habilitar Google Cloud Managed Service para Prometheus, que recoge las métricas de TorchServe, en tu clúster de GKE. TorchServe expone las métricas en formato Prometheus de forma predeterminada, por lo que no es necesario instalar ningún exportador adicional.

Después, puede ver las métricas mediante el panel de control de TorchServe. Para obtener información sobre cómo usar Google Cloud Managed Service para Prometheus y recoger métricas de tu modelo, consulta la guía de observabilidad de TorchServe en la documentación de Cloud Monitoring.

Limpieza

Para evitar que los recursos utilizados en este tutorial se cobren en tu cuenta de Google Cloud, elimina el proyecto que contiene los recursos o conserva el proyecto y elimina los recursos.

Eliminar el proyecto

Precaución: Eliminar un proyecto tiene los siguientes efectos:

• Se elimina todo el contenido del proyecto. Si has usado un proyecto que ya existía para las tareas de este documento, cuando lo elimines, también se eliminará cualquier otro trabajo que hayas realizado en él.
• Se pierden los IDs de proyecto personalizados. Cuando creaste este proyecto, es posible que hayas creado un ID de proyecto personalizado que quieras usar en el futuro. Para conservar las URLs que usan el ID del proyecto, como una URL appspot.com, elimina los recursos seleccionados dentro del proyecto en lugar de eliminar todo el proyecto.

Si tienes previsto consultar varias arquitecturas, tutoriales o guías de inicio rápido, reutilizar los proyectos puede ayudarte a no superar los límites de cuota de proyectos.

Delete a Google Cloud project:

gcloud projects delete PROJECT_ID

Eliminar recursos concretos

1. Elimina los recursos de 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. Elimina el clúster de GKE:

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

3. Elimina la cuenta de servicio de gestión de identidades y accesos y los enlaces de la política de gestión de identidades y accesos:

   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. Elimina las imágenes de Artifact Registry. Si quieres, puedes eliminar todo el repositorio. Para obtener instrucciones, consulta la documentación de Artifact Registry sobre cómo eliminar imágenes.

Descripción general de los componentes

En esta sección se describen los componentes que se usan en este tutorial, como el modelo, la aplicación web, el framework y el clúster.

Acerca del modelo T5

En este tutorial se usa un modelo T5 multilingüe preentrenado. T5 es un transformador de texto a texto que convierte texto de un idioma a otro. En T5, las entradas y las salidas siempre son cadenas de texto, a diferencia de los modelos de estilo BERT, que solo pueden generar una etiqueta de clase o un intervalo de la entrada. El modelo T5 también se puede usar para tareas como resúmenes, preguntas y respuestas o clasificación de texto. El modelo se entrena con una gran cantidad de texto de Colossal Clean Crawled Corpus (C4) y Wiki-DPR.

Para obtener más información, consulta la documentación del modelo T5.

Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li y Peter J. Liu presentó el modelo T5 en el artículo Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer, publicado en el Journal of Machine Learning Research.

El modelo T5 admite varios tamaños de modelo, con diferentes niveles de complejidad que se adaptan a casos prácticos específicos. En este tutorial se usa el tamaño predeterminado, t5-small, pero también puedes elegir otro tamaño. Los siguientes tamaños de T5 se distribuyen bajo la licencia Apache 2.0:

• t5-small: 60 millones de parámetros
• t5-base: 220 millones de parámetros
• t5-large: 770 millones de parámetros. Descarga de 3 GB.
• t5-3b: 3000 millones de parámetros. Descarga de 11 GB.
• t5-11b: 11.000 millones de parámetros. Descarga de 45 GB.

Para ver otros modelos T5 disponibles, consulta el repositorio de Hugging Face.

Acerca de TorchServe

TorchServe es una herramienta flexible para servir modelos de PyTorch. Ofrece compatibilidad de serie con los principales frameworks de aprendizaje profundo, como PyTorch, TensorFlow y ONNX. TorchServe se puede usar para desplegar modelos en producción o para crear prototipos y experimentar rápidamente.

Siguientes pasos

• Sirve un LLM con varias GPUs.
• Consulta arquitecturas de referencia, diagramas y prácticas recomendadas sobre Google Cloud. Consulta nuestro Centro de arquitectura de Cloud.