Entrega un LLM con TPU en GKE con JetStream y PyTorch

Autopilot estándar

Nota: vLLM ahora es la solución recomendada para entregar LLMs en TPU en GKE. Para comenzar, consulta Entrega un LLM usando TPU Trillium en GKE con vLLM.

En esta guía, se muestra cómo entregar un modelo de lenguaje grande (LLM) que usa unidades de procesamiento tensorial (TPU) en Google Kubernetes Engine (GKE) con JetStream a través de PyTorch. En esta guía, descargarás ponderaciones de modelos en Cloud Storage y, luego, las implementarás en un clúster de Autopilot o Standard de GKE con un contenedor que ejecute JetStream.

Si necesitas la escalabilidad, la resiliencia y la rentabilidad que ofrecen las funciones de Kubernetes cuando implementas tu modelo en JetStream, esta guía es un buen punto de partida.

Esta guía está dirigida a clientes de IA generativa que usan PyTorch, usuarios nuevos o existentes de GKE, ingenieros de AA, ingenieros de MLOps (DevOps) o administradores de plataformas interesados en usar las funciones de organización de contenedores de Kubernetes para entrega de LLM.

Antecedentes

Con la entrega de un LLM con TPU en GKE con JetStream, puedes compilar una solución de entrega sólida y lista para la producción con todos los beneficios de Kubernetes administrado, incluida la rentabilidad, escalabilidad y disponibilidad mayor. En esta sección, se describen las tecnologías clave que se usan en este instructivo.

Acerca de las TPU

Las TPU son circuitos integrados personalizados específicos de aplicaciones (ASIC) de Google que se usan para acelerar el aprendizaje automático y los modelos de IA compilados con frameworks como el siguiente:TensorFlow, PyTorch yJAX.

Antes de usar las TPU en GKE, te recomendamos que completes la siguiente ruta de aprendizaje:

1. Obtén información sobre la disponibilidad actual de la versión de TPU con la arquitectura del sistema de Cloud TPU.
2. Obtén información sobre las TPU en GKE.

En este instructivo, se aborda la entrega de varios modelos de LLM. GKE implementa el modelo en los nodos TPUv5e de host único con topologías de TPU configuradas según los requisitos del modelo para entregar mensajes con baja latencia.

Acerca de JetStream

JetStream es un framework de entrega de inferencia de código abierto que desarrolla Google. JetStream permite la inferencia de alto rendimiento, alta capacidad de procesamiento y con optimización de memoria en TPU y GPU. JetStream proporciona optimizaciones de rendimiento avanzadas, incluidas técnicas de procesamiento por lotes, optimizaciones de la caché de KV y de cuantización continuas, para facilitar la implementación de LLM. JetStream permite que PyTorch/XLA y JAX TPU entreguen un rendimiento óptimo.

Agrupación en lotes continua

El procesamiento por lotes continuo es una técnica que agrupa de forma dinámica las solicitudes de inferencia entrantes en lotes, lo que reduce la latencia y aumenta la capacidad de procesamiento.

Cuantización de la caché de KV

La cuantización de la caché de par clave-valor implica comprimir la caché de par clave-valor que se usa en los mecanismos de atención, lo que reduce los requisitos de memoria.

Cuantización del peso en Int8

La cuantización del peso de Int8 reduce la precisión de los pesos del modelo de punto flotante de 32 bits a números enteros de 8 bits, lo que permite un procesamiento más rápido y un uso de memoria reducido.

Para obtener más información sobre estas optimizaciones, consulta los repositorios de proyectos de JetStream PyTorch y JetStream MaxText.

Acerca de PyTorch

PyTorch es un framework de aprendizaje automático de código abierto desarrollado por Meta y ahora parte del paraguas de la Linux Foundation. PyTorch proporciona funciones de alto nivel, como el procesamiento de tensores y las redes neuronales profundas.

Objetivos

1. Prepara un clúster de GKE en modo Autopilot o Estándar con la topología de TPU recomendada según las características del modelo.
2. Implementa componentes de JetStream en GKE.
3. Obtén y publica tu modelo.
4. Entrega el modelo publicado y, luego, interactúa con él.

Arquitectura

En esta sección, se describe la arquitectura de GKE que se usa en este instructivo. La arquitectura consta de un clúster de GKE en modo Autopilot o Standard que aprovisiona TPU y aloja componentes de JetStream para implementar y entregar los modelos.

En el siguiente diagrama, se muestran los componentes de esta arquitectura:

Esta arquitectura incluye los siguientes componentes:

• Un clúster regional de GKE en modo Autopilot o Estándar.
• Dos grupos de nodos de porción de TPU de host único que alojan la implementación de JetStream.
• El componente de Service distribuye el tráfico entrante a todas las réplicas de JetStream HTTP.
• JetStream HTTP es un servidor HTTP que acepta solicitudes como wrapper del formato requerido de JetStream y las envía al cliente GRPC de JetStream.
• JetStream-PyTorch es un servidor de JetStream que ejecuta inferencias con procesamiento por lotes continuo.

Antes de comenzar

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

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

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.

     Ir a IAM
  2. Selecciona el proyecto.
  3. Haz clic en Otorgar acceso.

  4. En el campo Principales nuevas, ingresa tu identificador de usuario. Esta suele ser la dirección de correo electrónico de una Cuenta de Google.

  5. En la lista Seleccionar un rol, elige uno.
  6. Para otorgar roles adicionales, haz clic en Agregar otro rol y agrega uno más.
  7. Haz clic en Guardar.
  • Verifica que tengas suficiente cuota para ocho chips TPU v5e PodSlice Lite. En este instructivo, usarás instancias bajo demanda.
  • Crea una cuenta de Hugging Face, si todavía no la tienes.

  Obtén acceso al modelo

  Obtén acceso a varios modelos en Hugging Face para la implementación en GKE

  Gemma 7B-it

  A fin de obtener acceso al modelo de Gemma para la implementación en GKE, primero debes firmar el acuerdo de consentimiento de licencia.

  1. Accede a la página de consentimiento del modelo de Gemma en Hugging Face.
  2. Accede a Hugging Face si aún no lo hiciste.
  3. Revisa y acepta los Términos y Condiciones del modelo.

  Llama 3 8B

  Para obtener acceso al modelo de Llama 3 para la implementación en GKE, primero debes firmar el acuerdo de consentimiento de licencia.

  1. Accede a la página de consentimiento del modelo de Llama 3 en Hugging Face
  2. Accede a Hugging Face si aún no lo hiciste.
  3. Revisa y acepta los Términos y Condiciones del modelo.

  Prepare el entorno

  En este instructivo, usarás Cloud Shell para administrar recursos alojados enGoogle Cloud. Cloud Shell tiene preinstalado el software que necesitarás para este instructivo, incluidos kubectl y la CLI de gcloud.

  Para configurar tu entorno con Cloud Shell, sigue estos pasos:

  1. En la Google Cloud consola, haz clic en Activar Cloud Shell en la Google Cloud consola para iniciar una sesión de Cloud Shell. Esto inicia una sesión en el panel inferior de la consola de Google Cloud .

  2. Configura las variables de entorno predeterminadas:

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

     Reemplaza los siguientes valores:

     • PROJECT_ID: Es el Google Cloud ID de tu proyecto.
     • CLUSTER_NAME: Es el nombre del clúster de GKE.
     • CONTROL_PLANE_LOCATION: La región de Compute Engine del plano de control de tu clúster. La región debe contener zonas en las que los tipos de máquinas de TPU v5e estén disponibles (por ejemplo, us-west1, us-west4, us-central1, us-east1, us-east5 o europe-west4). Para los clústeres de Autopilot, asegúrate de tener suficientes recursos zonales de TPU v5e para la región que elijas.
     • (Solo clúster estándar) NODE_LOCATION: Es la zona en la que los recursos de TPU están disponibles (por ejemplo, us-west4-a). Para los clústeres de Autopilot, no necesitas especificar este valor.
     • CLUSTER_VERSION: la versión de GKE, que debe ser compatible con el tipo de máquina que deseas usar. Ten en cuenta que es posible que la versión predeterminada de GKE no tenga disponibilidad para la TPU de destino. Para obtener una lista de las versiones mínimas de GKE disponibles por tipo de máquina de TPU, consulta disponibilidad de TPU en GKE.
     • BUCKET_NAME: Es el nombre de tu bucket de Cloud Storage, que se usa para almacenar la caché de compilación de JAX.

  Crea y configura recursos de Google Cloud

  Sigue estas instrucciones para crear los recursos necesarios.

  Nota: Es posible que debas crear una reserva de capacidad para el uso de algunos aceleradores. Para obtener información sobre cómo reservar y consumir recursos reservados, consulta Consume recursos zonales reservados.

  Crea un clúster de GKE

  Puedes entregar Gemma en TPU en un clúster de GKE Autopilot o Estándar. Te recomendamos que uses un clúster en modo Autopilot para una experiencia de Kubernetes completamente administrada. Para elegir el modo de operación de GKE que se adapte mejor a tus cargas de trabajo, consulta Elige un modo de operación de GKE.

  Autopilot

  Crea un clúster de GKE Autopilot:

  gcloud container clusters create-auto CLUSTER_NAME \
      --project=PROJECT_ID \
      --location=CONTROL_PLANE_LOCATION \
      --cluster-version=CLUSTER_VERSION
  

  Reemplaza CLUSTER_VERSION por la versión del clúster adecuada. En el caso de un clúster de GKE Autopilot, usa una versión del canal de versiones regular.

  Estándar

  1. Crea un clúster de GKE Estándar regional que use la federación de identidades para cargas de trabajo en 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
     

     La creación del clúster puede tomar varios minutos.

     Reemplaza CLUSTER_VERSION por la versión del clúster adecuada.

  2. Crea un grupo de nodos TPU v5e con una topología 2x4 y dos nodos:

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

  Genera tu token de CLI de Hugging Face en Cloud Shell

  Genera un nuevo token de Hugging Face si aún no tienes uno:

  1. Haz clic en Tu perfil > Configuración > Tokens de acceso.
  2. Haz clic en Token nuevo.
  3. Especifica el nombre que desees y un rol de al menos Read.
  4. Haz clic en Generar un token.
  5. Edita los permisos de tu token de acceso para tener acceso de lectura al repositorio de Hugging Face de tu modelo.
  6. Copia el token generado al portapapeles.

  Crea un secreto de Kubernetes para las credenciales de Hugging Face

  En Cloud Shell, haz lo siguiente:

  1. Configura kubectl para comunicarse con tu clúster:

     gcloud container clusters get-credentials CLUSTER_NAME --location=CONTROL_PLANE_LOCATION
     

  2. Crea un Secret para almacenar las credenciales de Hugging Face:

     kubectl create secret generic huggingface-secret \
         --from-literal=HUGGINGFACE_TOKEN=HUGGINGFACE_TOKEN
     

     Reemplaza HUGGINGFACE_TOKEN por tu token de Hugging Face.

  Configura el acceso a tus cargas de trabajo mediante la federación de identidades para cargas de trabajo para GKE

  Asigna una Cuenta de servicio de Kubernetes a la aplicación y configúrala para que actúe como una cuenta de servicio de IAM.

  1. Crea una cuenta de servicio de IAM para tu aplicación:

     gcloud iam service-accounts create wi-jetstream
     

  2. Agrega una vinculación de política de IAM para que tu cuenta de servicio de IAM administre 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. Para permitir que la cuenta de servicio de Kubernetes actúe en nombre de la cuenta de servicio de IAM, agrega una vinculación de política de IAM entre las dos. Esta vinculación permite que la cuenta de servicio de Kubernetes actúe como la cuenta de servicio de 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. Anota la cuenta de servicio de Kubernetes con la dirección de correo electrónico de la cuenta de servicio de IAM.

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

  Implementa JetStream

  Implementa el contenedor de JetStream para entregar tu modelo. En este instructivo, se usan manifiestos de implementación 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.

  Guarda el siguiente manifiesto como jetstream-pytorch-deployment.yaml:

  Gemma 7B-it

  apiVersion: apps/v1
  kind: Deployment
  metadata:
    name: jetstream-pytorch-server
  spec:
    replicas: 2
    selector:
      matchLabels:
        app: jetstream-pytorch-server
    template:
      metadata:
        labels:
          app: jetstream-pytorch-server
      spec:
        nodeSelector:
          cloud.google.com/gke-tpu-topology: 2x4
          cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
        containers:
        - name: jetstream-pytorch-server
          image: us-docker.pkg.dev/cloud-tpu-images/inference/jetstream-pytorch-server:v0.2.4
          args:
          - --model_id=google/gemma-7b-it
          - --override_batch_size=30
          - --enable_model_warmup=True
          volumeMounts:
          - name: huggingface-credentials
            mountPath: /huggingface
            readOnly: true
          ports:
          - containerPort: 9000
          resources:
            requests:
              google.com/tpu: 8
            limits:
              google.com/tpu: 8
          startupProbe:
            httpGet:
              path: /healthcheck
              port: 8000
              scheme: HTTP
            periodSeconds: 60
            initialDelaySeconds: 90
            failureThreshold: 50
          livenessProbe:
            httpGet:
              path: /healthcheck
              port: 8000
              scheme: HTTP
            periodSeconds: 60
            failureThreshold: 30
          readinessProbe:
            httpGet:
              path: /healthcheck
              port: 8000
              scheme: HTTP
            periodSeconds: 60
            failureThreshold: 30
        - name: jetstream-http
          image: us-docker.pkg.dev/cloud-tpu-images/inference/jetstream-http:v0.2.3
          ports:
          - containerPort: 8000
        volumes:
        - name: huggingface-credentials
          secret:
            defaultMode: 0400
            secretName: huggingface-secret
  ---
  apiVersion: v1
  kind: Service
  metadata:
    name: jetstream-svc
  spec:
    selector:
      app: jetstream-pytorch-server
    ports:
    - protocol: TCP
      name: jetstream-http
      port: 8000
      targetPort: 8000

  Llama 3 8B

  apiVersion: apps/v1
  kind: Deployment
  metadata:
    name: jetstream-pytorch-server
  spec:
    replicas: 2
    selector:
      matchLabels:
        app: jetstream-pytorch-server
    template:
      metadata:
        labels:
          app: jetstream-pytorch-server
      spec:
        nodeSelector:
          cloud.google.com/gke-tpu-topology: 2x4
          cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
        containers:
        - name: jetstream-pytorch-server
          image: us-docker.pkg.dev/cloud-tpu-images/inference/jetstream-pytorch-server:v0.2.4
          args:
          - --model_id=meta-llama/Meta-Llama-3-8B
          - --override_batch_size=30
          - --enable_model_warmup=True
          volumeMounts:
          - name: huggingface-credentials
            mountPath: /huggingface
            readOnly: true
          ports:
          - containerPort: 9000
          resources:
            requests:
              google.com/tpu: 8
            limits:
              google.com/tpu: 8
          startupProbe:
            httpGet:
              path: /healthcheck
              port: 8000
              scheme: HTTP
            periodSeconds: 60
            initialDelaySeconds: 90
            failureThreshold: 50
          livenessProbe:
            httpGet:
              path: /healthcheck
              port: 8000
              scheme: HTTP
            periodSeconds: 60
            failureThreshold: 30
          readinessProbe:
            httpGet:
              path: /healthcheck
              port: 8000
              scheme: HTTP
            periodSeconds: 60
            failureThreshold: 30
        - name: jetstream-http
          image: us-docker.pkg.dev/cloud-tpu-images/inference/jetstream-http:v0.2.3
          ports:
          - containerPort: 8000
        volumes:
        - name: huggingface-credentials
          secret:
            defaultMode: 0400
            secretName: huggingface-secret
  ---
  apiVersion: v1
  kind: Service
  metadata:
    name: jetstream-svc
  spec:
    selector:
      app: jetstream-pytorch-server
    ports:
    - protocol: TCP
      name: jetstream-http
      port: 8000
      targetPort: 8000

  El manifiesto establece las siguientes propiedades clave:

  • model_id: Es el nombre del modelo de Hugging Face (google/gemma-7b-it, meta-llama/Meta-Llama-3-8B) (consulta los modelos compatibles).
  • override_batch_size: Es el tamaño del lote de decodificación por dispositivo, en el que un chip TPU equivale a un dispositivo. El valor predeterminado es 30.
  • enable_model_warmup: Este parámetro de configuración habilita el calentamiento del modelo después de que se inicia el servidor del modelo. El valor predeterminado es False.

  De forma opcional, puedes establecer estas propiedades:

  • max_input_length: Es la longitud máxima de la secuencia de entrada. El valor predeterminado es 1024.
  • max_output_length: Es la longitud máxima de decodificación de salida. El valor predeterminado es 1024.
  • quantize_weights: si el punto de control está cuantizado. El valor predeterminado es 0. Configúralo en 1 para habilitar la cuantificación de int8.
  • internal_jax_compilation_cache: Es el directorio de la caché de compilación de JAX. El valor predeterminado es ~/jax_cache; configúralo como gs://BUCKET_NAME/jax_cache para el almacenamiento en caché remoto.

  En el manifiesto, se configura un sondeo de inicio para garantizar que el servidor del modelo se etiquete como Ready después de que se cargue el modelo y se complete el calentamiento. Los sondeos de funcionamiento y preparación se configuran para garantizar el buen estado del servidor del modelo.

  1. Aplica el manifiesto

     kubectl apply -f jetstream-pytorch-deployment.yaml
     

  2. Verifica la implementación:

     kubectl get deployment
     

     El resultado es similar a este:

     NAME                              READY   UP-TO-DATE   AVAILABLE   AGE
     jetstream-pytorch-server          0/2     2            0           ##s
     

     En el caso de los clústeres Autopilot, puede tardar unos minutos en aprovisionar los recursos TPU necesarios.

  3. Visualiza los registros del servidor de JetStream-PyTorch para verificar que se hayan cargado los pesos del modelo y que se haya completado el calentamiento del modelo. Es posible que el servidor tarde unos minutos en completar esta operación.

     kubectl logs deploy/jetstream-pytorch-server -f -c jetstream-pytorch-server
     

     El resultado es similar a lo siguiente:

     Started jetstream_server....
     2024-04-12 04:33:37,128 - root - INFO - ---------Generate params 0 loaded.---------
     

  4. Verifica que la Deployment esté lista:

     kubectl get deployment
     

     El resultado es similar a lo siguiente:

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

     El registro del extremo healthcheck puede tardar varios minutos.

  Entrega el modelo

  En esta sección, interactuarás con el modelo.

  Configura la redirección de puertos

  Puedes acceder a la implementación de JetStream a través del Service de ClusterIP que creaste en el paso anterior. Solo se puede acceder a los servicios de ClusterIP desde el clúster. Por lo tanto, para acceder al servicio desde fuera del clúster, completa los siguientes pasos:

  Para establecer una sesión de redirección de puertos, ejecuta el siguiente comando:

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

  Interactúa con el modelo con curl

  1. Para comprobar que puedes acceder al servidor HTTP de JetStream, abre una terminal nueva y ejecuta el siguiente 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
     }'
     

     La solicitud inicial puede tardar varios segundos en completarse debido a la preparación del modelo. El resultado es similar a lo siguiente:

     {
         "response": " for data science in 2023?\n\n**1. Python:**\n- Widely used for data science due to its readability, extensive libraries (pandas, scikit-learn), and integration with other tools.\n- High demand for Python programmers in data science roles.\n\n**2. R:**\n- Popular choice for data analysis and visualization, particularly in academia and research.\n- Extensive libraries for statistical modeling and data wrangling.\n\n**3. Java:**\n- Enterprise-grade platform for data science, with strong performance and scalability.\n- Widely used in data mining and big data analytics.\n\n**4. SQL:**\n- Essential for data querying and manipulation, especially in relational databases.\n- Used for data analysis and visualization in various industries.\n\n**5. Scala:**\n- Scalable and efficient for big data processing and machine learning models.\n- Popular in data science for its parallelism and integration with Spark and Spark MLlib."
     }
     
     

  Completaste correctamente lo siguiente:

  1. Se implementó el servidor de modelos JetStream-PyTorch en GKE con TPU.
  2. Se entregó el modelo y se interactuó con él.

  Observa el rendimiento del modelo

  Para observar el rendimiento del modelo, puedes usar la integración del panel de JetStream 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 JetStream, debes habilitar Google Cloud Managed Service para Prometheus, que recopila las métricas de JetStream, en tu clúster de GKE.

  Luego, puedes ver las métricas con el panel de JetStream. 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 JetStream en la documentación de Cloud Monitoring.

  Soluciona problemas

  • Si recibes el mensaje Empty reply from server, es posible que el contenedor no haya terminado de descargar los datos del modelo. Vuelve a verificar los registros del Pod en busca del mensaje Connected, que indica que el modelo está listo para entregar.
  • Si ves Connection refused, verifica que tu redirección de puertos esté activa.

  Realiza una limpieza

  Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos usados en este instructivo, borra el proyecto que contiene los recursos o conserva el proyecto y borra los recursos individuales.

  Borra los recursos implementados

  Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos que creaste en esta guía, ejecuta los siguientes comandos y sigue las indicaciones:

  gcloud container clusters delete CLUSTER_NAME --location=CONTROL_PLANE_LOCATION
  
  gcloud iam service-accounts delete wi-jetstream@PROJECT_ID.iam.gserviceaccount.com
  

  ¿Qué sigue?

  • Descubre cómo puedes ejecutar modelos de Gemma en GKE y cómo ejecutar cargas de trabajo de IA/AA optimizadas con las funciones de organización de la plataforma de GKE.
  • Obtén más información sobre las TPU en GKE.
  • Explora el repositorio de GitHub de JetStream.
  • Explora Vertex AI Model Garden.