Entrega un LLM con TPU en GKE con JetStream y PyTorch

Autopilot Estándar

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:

Obtén información sobre la disponibilidad actual de la versión de TPU con la arquitectura del sistema de Cloud TPU.
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

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.
Implementa componentes de JetStream en GKE.
Obtén y publica tu modelo.
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:

Arquitectura del clúster de GKE con grupos de nodos TPU de host único que contienen los componentes HTTP de JetStream-PyTorch y JetStream.

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.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the required API.

Enable the API

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the required API.

Enable the API

Make sure that you have the following role or roles on the project: roles/container.admin, roles/iam.serviceAccountAdmin
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 colunn 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 Grant access.
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 un rol.
6. Para otorgar funciones adicionales, haz clic en Agregar otro rol y agrega cada rol adicional.
7. Haz clic en Guardar.

Asegúrate de tener 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.

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

Llama 3 8B

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

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

Prepare el entorno

En este instructivo, usarás Cloud Shell para administrar recursos alojados en Google 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:

En la consola de Google Cloud, haz clic en Activar Cloud Shell en la consola de Google Cloud para iniciar una sesión de Cloud Shell. Esto inicia una sesión en el panel inferior de la consola de Google Cloud.
Configura las variables de entorno predeterminadas:
```
gcloud config set project PROJECT_ID
export PROJECT_ID=$(gcloud config get project)
export CLUSTER_NAME=CLUSTER_NAME
export BUCKET_NAME=BUCKET_NAME
export REGION=REGION
export LOCATION=LOCATION
export CLUSTER_VERSION=CLUSTER_VERSION
```
Reemplaza los siguientes valores:
- PROJECT_ID: El ID del proyecto de Google Cloud.
- CLUSTER_NAME: Es el nombre del clúster de GKE.
- BUCKET_NAME: Es el nombre de tu bucket de Cloud Storage. No es necesario especificar el prefijo gs://.
- REGION: La región en la que se encuentran el clúster de GKE, el bucket de Cloud Storage y los nodos TPU. La región contiene 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 Autopilot, asegúrate de tener suficientes recursos zonales de TPU v5e para la región que elijas.
- (Solo clúster estándar) LOCATION: Es la zona en la que los recursos de TPU están disponibles (por ejemplo, us-west4-a). Para los clústeres en modo Autopilot, no necesitas especificar la zona, solo la región.
- 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.

Crea y configura recursos de Google Cloud

Sigue estas instrucciones para crear los recursos necesarios.

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 \
    --region=REGION \
    --cluster-version=CLUSTER_VERSION

Estándar

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=REGION

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

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 \
  --region=REGION \
  --node-locations=LOCATION

Cree un bucket de Cloud Storage

Crea un bucket de Cloud Storage para almacenar el punto de control convertido:

gcloud storage buckets create gs://BUCKET_NAME --location=REGION

Genera tu token de CLI de Hugging Face en Cloud Shell

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

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

Crea un secreto de Kubernetes para las credenciales de Hugging Face

En Cloud Shell, haz lo siguiente:

Configura kubectl para comunicarse con tu clúster:

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

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.

Crea una cuenta de servicio de IAM para tu aplicación:
```
gcloud iam service-accounts create wi-jetstream
```

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

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]"
```

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

Convierte los puntos de control del modelo

En esta sección, crearás un trabajo para llevar a cabo la siguiente acción:

Descarga el punto de control base de Hugging Face al directorio local.
Convierte el punto de control en un punto de control compatible con JetStream-Pytorch.
Sube el punto de control a un bucket de Cloud Storage.

Implementa el trabajo de conversión de punto de control del modelo

Gemma 7B-it

Descarga y convierte los archivos de punto de control del modelo Gemma 7B:

Guarda el siguiente manifiesto como job-checkpoint-converter.yaml:

apiVersion: batch/v1
kind: Job
metadata:
  name: checkpoint-converter
spec:
  ttlSecondsAfterFinished: 30
  template:
    spec:
      restartPolicy: Never
      containers:
      - name: inference-checkpoint
        image: us-docker.pkg.dev/cloud-tpu-images/inference/inference-checkpoint:v0.2.3
        args:
        - -s=jetstream-pytorch
        - -m=google/gemma-7b-it-pytorch
        - -o=gs://BUCKET_NAME/pytorch/gemma-7b-it/final/bf16/
        - -n=gemma
        - -q=False
        - -h=True
        volumeMounts:
        - mountPath: "/huggingface/"
          name: huggingface-credentials
          readOnly: true
        resources:
          requests:
            google.com/tpu: 8
          limits:
            google.com/tpu: 8
      nodeSelector:
        cloud.google.com/gke-tpu-topology: 2x4
        cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
      volumes:
      - name: huggingface-credentials
        secret:
          defaultMode: 0400
          secretName: huggingface-secret

Llama 3 8B

Descarga y convierte los archivos de punto de control del modelo Llama 3 8B:

Guarda el siguiente manifiesto como job-checkpoint-converter.yaml:

apiVersion: batch/v1
kind: Job
metadata:
  name: checkpoint-converter
spec:
  ttlSecondsAfterFinished: 30
  template:
    spec:
      restartPolicy: Never
      containers:
      - name: inference-checkpoint
        image: us-docker.pkg.dev/cloud-tpu-images/inference/inference-checkpoint:v0.2.3
        args:
        - -s=jetstream-pytorch
        - -m=meta-llama/Meta-Llama-3-8B
        - -o=gs://BUCKET_NAME/pytorch/llama-3-8b/final/bf16/
        - -n=llama-3
        - -q=False
        - -h=True
        volumeMounts:
        - mountPath: "/huggingface/"
          name: huggingface-credentials
          readOnly: true
        resources:
          requests:
            google.com/tpu: 8
          limits:
            google.com/tpu: 8
      nodeSelector:
        cloud.google.com/gke-tpu-topology: 2x4
        cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
      volumes:
      - name: huggingface-credentials
        secret:
          defaultMode: 0400
          secretName: huggingface-secret

Reemplaza BUCKET_NAME por el GSBucket que creaste antes:

sed -i "s|BUCKET_NAME|BUCKET_NAME|g" job-checkpoint-converter.yaml

Aplica el manifiesto

kubectl apply -f job-checkpoint-converter.yaml

Espera a que el Pod que programa el trabajo comience a ejecutarse:
```
kubectl get pod -w
```
El resultado será similar al siguiente, y puede tardar unos minutos:
```
NAME                        READY   STATUS              RESTARTS   AGE
checkpoint-converter-abcd   0/1     ContainerCreating   0          28s
checkpoint-converter-abcd   1/1     Running             0          51s
```
En el caso de los clústeres Autopilot, puede tardar unos minutos en aprovisionar los recursos TPU necesarios.

Verifica que el trabajo se haya completado. Para ello, visualiza los registros del trabajo:

kubectl logs -f jobs/checkpoint-converter

Cuando se completa el trabajo, el resultado es similar al siguiente:

Completed uploading converted checkpoint from local path /pt-ckpt/ to GSBucket gs://BUCKET_NAME/pytorch/<model_name>/final/bf16/"

Implementa JetStream

Implementa el contenedor de JetStream para entregar tu modelo:

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
      annotations:
        gke-gcsfuse/volumes: "true"
    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.3
        args:
        - --size=7b
        - --model_name=gemma
        - --batch_size=32
        - --max_cache_length=2048
        - --quantize_weights=False
        - --quantize_kv_cache=False
        - --tokenizer_path=/models/pytorch/gemma-7b-it/final/bf16/tokenizer.model
        - --checkpoint_path=/models/pytorch/gemma-7b-it/final/bf16/model.safetensors
        ports:
        - containerPort: 9000
        volumeMounts:
        - name: gcs-fuse-checkpoint
          mountPath: /models
          readOnly: true
        resources:
          requests:
            google.com/tpu: 8
          limits:
            google.com/tpu: 8
      - name: jetstream-http
        image: us-docker.pkg.dev/cloud-tpu-images/inference/jetstream-http:v0.2.2
        ports:
        - containerPort: 8000
      volumes:
      - name: gcs-fuse-checkpoint
        csi:
          driver: gcsfuse.csi.storage.gke.io
          readOnly: true
          volumeAttributes:
            bucketName: BUCKET_NAME
            mountOptions: "implicit-dirs"
---
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
      annotations:
        gke-gcsfuse/volumes: "true"
    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.3
        args:
        - --size=8b
        - --model_name=llama-3
        - --batch_size=32
        - --max_cache_length=2048
        - --quantize_weights=False
        - --quantize_kv_cache=False
        - --tokenizer_path=/models/pytorch/llama-3-8b/final/bf16/tokenizer.model
        - --checkpoint_path=/models/pytorch/llama-3-8b/final/bf16/model.safetensors
        ports:
        - containerPort: 9000
        volumeMounts:
        - name: gcs-fuse-checkpoint
          mountPath: /models
          readOnly: true
        resources:
          requests:
            google.com/tpu: 8
          limits:
            google.com/tpu: 8
      - name: jetstream-http
        image: us-docker.pkg.dev/cloud-tpu-images/inference/jetstream-http:v0.2.2
        ports:
        - containerPort: 8000
      volumes:
      - name: gcs-fuse-checkpoint
        csi:
          driver: gcsfuse.csi.storage.gke.io
          readOnly: true
          volumeAttributes:
            bucketName: BUCKET_NAME
            mountOptions: "implicit-dirs"
---
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:

size: el tamaño del modelo.
model_name: el nombre del modelo (gemma, llama-3).
batch_size: Es el tamaño del lote de decodificación por dispositivo, en el que un chip TPU equivale a un dispositivo.
max_cache_length: la longitud máxima de la caché kv.
quantize_weights: si el punto de control está cuantizado.
quantize_kv_cache: si la caché kv está cuantizada.
tokenizer_path: la ruta de acceso al archivo del tokenizador del modelo.
checkpoint_path: la ruta de acceso al punto de control.

Reemplaza BUCKET_NAME por el GSBucket que creaste antes:

sed -i "s|BUCKET_NAME|BUCKET_NAME|g" jetstream-pytorch-deployment.yaml

Aplica el manifiesto

kubectl apply -f jetstream-pytorch-deployment.yaml

Verifica la implementación:

kubectl get deployment

El resultado es similar a este:

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

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

Consulta los registros del servidor HTTP para comprobar que el modelo se cargó y compiló. Es posible que el servidor tarde unos minutos en completar esta operación.

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

El resultado es similar a este:

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

INFO:     Started server process [1]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C to quit)

Visualiza los registros del servidor de JetStream-PyTorch y verifica que se haya realizado la compilación:

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

El resultado es similar a este:

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

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

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 este:

{
    "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."
}

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 generen cargos en 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 --region=REGION

gcloud iam service-accounts delete wi-jetstream@PROJECT_ID.iam.gserviceaccount.com

gcloud storage rm --recursive gs://BUCKET_NAME

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

Entrega un LLM con TPU en GKE con JetStream y PyTorch

Antecedentes

Acerca de las TPU

Acerca de JetStream

Acerca de PyTorch

Objetivos

Arquitectura

Antes de comenzar

Check for the roles

Grant the roles

Obtén acceso al modelo

Gemma 7B-it

Llama 3 8B

Prepare el entorno

Crea y configura recursos de Google Cloud

Crea un clúster de GKE

Autopilot

Estándar

Cree un bucket de Cloud Storage

Genera tu token de CLI de Hugging Face en Cloud Shell

Crea un secreto de Kubernetes para las credenciales de Hugging Face

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

Convierte los puntos de control del modelo

Implementa el trabajo de conversión de punto de control del modelo

Gemma 7B-it

Llama 3 8B

Implementa JetStream

Gemma 7B-it

Llama 3 8B

Entrega el modelo

Configura la redirección de puertos

Interactúa con el modelo con curl

Soluciona problemas

Realiza una limpieza

Borra los recursos implementados

¿Qué sigue?