Entrega LLMs escalables en GKE con TorchServe

En este instructivo, se muestra cómo implementar y entregar un modelo de aprendizaje automático (AA) escalable en un clúster de Google Kubernetes Engine (GKE) con el framework de TorchServe. Entregarás un modelo de PyTorch previamente entrenado que genera predicciones basadas en las solicitudes de los usuarios. Después de implementar 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 implementas la carga de trabajo y la aplicación de AA en Autopilot, GKE elige el tipo y el tamaño de máquina subyacentes más eficientes para ejecutar las cargas de trabajo.

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

Antes de leer esta página, asegúrate de estar familiarizado con el modo Autopilot de GKE.

Acerca de la aplicación del instructivo

La aplicación es una pequeña aplicación web de Python creada con el framework de Fast Dash. Usa la aplicación para enviar solicitudes de predicción al modelo T5. Esta aplicación captura las entradas de texto del usuario y los pares de idiomas, y envía la información al modelo. El modelo traduce el texto y muestra 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.

Prepare el entorno

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

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

Crea 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

Reemplaza lo siguiente:

• RELEASE_CHANNEL: Es el canal de versiones del 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 GPU L4. Para ver las versiones disponibles en un canal específico, consulta Visualiza las versiones predeterminadas y disponibles para los canales de versiones.
• CLUSTER_VERSION: la versión de GKE que se usará. Debe ser 1.28.3-gke.1203000 o una versión posterior.

Esta operación tarda varios minutos en completarse.

Crea un repositorio de Artifact Registry

1. Crea un repositorio estándar nuevo 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 es 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'
   

Empaqueta el modelo

En esta sección, empaquetas el modelo y el framework de entrega en una sola imagen de contenedor con Cloud Build y envías la imagen resultante al repositorio de Artifact Registry.

1. Revisa el Dockerfile para 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 Dockerfile define el siguiente proceso de compilación de varias etapas:

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

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

   La finalización del proceso de compilación toma varios minutos. Si usas un tamaño de modelo mayor que t5-small, el proceso de compilación puede tomar mucho más tiempo.

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

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

   Reemplaza PROJECT_ID por el ID del proyecto Google Cloud.

   El resultado es similar a este:

   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
   

Implementa el modelo empaquetado en GKE

Para implementar la imagen, en este instructivo, se usan implementaciones de Kubernetes. Un Deployment es un objeto de la API de Kubernetes que te permite ejecutar varias réplicas de Pods que se distribuyen entre los nodos de un clúster.

Modifica el manifiesto de Kubernetes en el repositorio de ejemplo para que coincida con tu entorno.

1. Revisa el manifiesto para 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. Reemplaza PROJECT_ID por el ID del proyecto: Google Cloud

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

   Esto garantiza que la ruta de la imagen de contenedor en la especificación del Deployment coincida con la ruta a la imagen del modelo T5 en Artifact Registry.

3. Crea los recursos de Kubernetes:

   kubectl create -f kubernetes/serving-gpu.yaml
   

Para verificar que el modelo se haya implementado correctamente, haz lo siguiente:

1. Obtén el estado del Deployment y el Service:

   kubectl get -f kubernetes/serving-gpu.yaml
   

   Espera hasta que el resultado muestre los Pods listos, similar a lo siguiente. Según el tamaño de la imagen, la primera extracción de 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 Service t5-inference:

   kubectl port-forward svc/t5-inference 8080
   

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

   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, verifica los registros:

   kubectl logs deployments/t5-inference
   

   Si el resultado es similar al siguiente, TorchServe no pudo instalar algunas dependencias del modelo:

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

   Para resolver este problema, reinicia el Deployment:

   kubectl rollout restart deployment t5-inference
   

   El controlador del Deployment crea un Pod nuevo. Repite los pasos anteriores para abrir un puerto en el Pod nuevo.

Accede al modelo implementado con la aplicación web

Para acceder al modelo implementado con la aplicación web de Fast Dash, completa los siguientes pasos:

1. Compila 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 reemplaza PROJECT_ID en el campo image: por el ID del proyecto. Como alternativa, ejecuta 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 Deployment y el Service pueden tardar un tiempo en aprovisionarse por completo.

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

   kubectl get -f kubernetes/application.yaml
   

   Espera hasta que el resultado muestre los Pods listos, similar a lo siguiente:

   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 ahora se está ejecutando, aunque no está expuesta 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 una shell local, abre un navegador y ve a http://127.0.0.1:8050.
   • Si usas Cloud Shell, haz clic en Vista previa en la Web y, luego, en Cambiar puerto. Especifica el puerto 8050.

7. Para enviar una solicitud al modelo T5, especifica los valores en los campos TEXTO, DE IDIOMA y A IDIOMA en la interfaz web y haz clic en Enviar. Para obtener una lista de los idiomas disponibles, consulta la documentación de T5.

Habilita el ajuste de escala automático para el modelo

En esta sección, se muestra cómo habilitar el ajuste de escala automático para el modelo según las métricas de Google Cloud Managed Service para Prometheus mediante los siguientes pasos:

1. Instala el adaptador de Stackdriver para métricas personalizadas
2. Aplica parámetros de configuración de PodMonitoring y HorizontalPodAutoscaling

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

Instala el adaptador de Stackdriver para métricas personalizadas

Este adaptador permite que tu clúster use métricas de Prometheus para tomar decisiones sobre el ajuste de escala 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. Otorga a la cuenta de servicio de IAM 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]"
   

   Reemplaza PROJECT_ID por el ID del proyecto Google Cloud.

4. Anota la cuenta de servicio de Kubernetes del adaptador para permitir que actúe en nombre de la cuenta de servicio de 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. Reinicia el adaptador para propagar los cambios:

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

Aplica parámetros de configuración de PodMonitoring y HorizontalPodAutoscaling

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

1. Implementa el recurso PodMonitoring en el mismo espacio de nombres que el Deployment 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"
   

   El HorizontalPodAutoscaler escala la cantidad de Pods del modelo T5 en función de la duración acumulativa de la cola de solicitudes. El ajuste de escala automático se basa en la métrica ts_queue_latency_microseconds, que muestra la duración acumulativa de la cola en microsegundos.

3. Crea el HorizontalPodAutoscaler:

   kubectl apply -f kubernetes/hpa.yaml
   

Verifica el ajuste de escala automático con un generador de cargas

A fin de probar tu configuración del ajuste de escala automático, genera carga para la aplicación de entrega. En este instructivo, se usa un generador de cargas de Locust para enviar solicitudes al extremo de predicción del modelo.

1. Crea el generador de cargas:

   kubectl apply -f kubernetes/loadgenerator.yaml
   

   Espera a que los Pods del generador de cargas estén listos.

2. Expón de manera local la interfaz web del generador de cargas:

   kubectl port-forward svc/loadgenerator 8080
   

   Si ves un mensaje de error, vuelve a intentarlo cuando el Pod se esté ejecutando.

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

   • 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 en la Web y, luego, en Cambiar puerto. Ingresa el puerto 8080.

4. Haz clic en la pestaña Charts para observar el rendimiento en el tiempo.

5. Abre una ventana de la terminal nueva y observa el recuento de réplicas de los escaladores automáticos horizontales de Pods:

   kubectl get hpa -w
   

   La cantidad de réplicas aumenta a medida que aumenta la carga. El escalamiento vertical puede tardar aproximadamente diez minutos. A medida que se inician réplicas nuevas, la cantidad de solicitudes exitosas en el chart de Locust aumenta.

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

Nota: El framework de Locust vuelve a usar las conexiones abiertas, por lo que no puedes ver los cambios en un chart después de un evento de escalamiento vertical. Sin embargo, puedes detener una ejecución actual del generador de cargas si haces clic en Detener y, luego, inicias una nueva prueba de generación de carga para observar el aumento en las solicitudes por segundo.

Recomendaciones

• Compila tu modelo con la misma versión de la imagen base de Docker que usarás para la entrega.
• 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 de Docker base.
• Mira la versión de árbol de los paquetes de dependencia del modelo. Asegúrate de que las dependencias de tus paquetes sean compatibles con las versiones de las demás. Por ejemplo, la versión 2.0.3 de Panda es compatible con NumPy versión 1.20.3 y posteriores.
• Ejecuta modelos con uso intensivo de GPU en nodos de GPU y modelos con uso intensivo de CPU en CPU. Esto podría mejorar la estabilidad de la entrega del modelo y garantizar que consumas los recursos de nodo de manera eficiente.

Observa el rendimiento del modelo

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

Para usar el panel de TorchServe, debes habilitar Google Cloud Managed Service para Prometheus, que recopila las métricas de TorchServe, en tu clúster de GKE. TorchServe expone las métricas en formato Prometheus de forma predeterminada. No es necesario que instales un exportador adicional.

Luego, puedes ver las métricas con el panel de TorchServe. Para obtener información sobre cómo usar Google Cloud Managed Service para Prometheus para recopilar métricas de tu modelo, consulta la guía de observabilidad de TorchServe en la documentación de Cloud Monitoring.