Entrega modelos abiertos de Gemma mediante GPUs en GKE con Hugging Face TGI

Autopilot Estándar

En este instructivo, se muestra cómo entregar el modelo de lenguaje grande (LLM) de Gemma, una familia de modelos abiertos, con unidades de procesamiento gráfico (GPU) en Google Kubernetes Engine (GKE) con el framework de entrega de Inferencia de generación de texto (TGI) de Hugging Face. En este instructivo, debes descargar los modelos de la familia Gemma previamente entrenados y ajustados por instrucciones de los parámetros 2B y 7B de Hugging Face y, luego, implementarlos en un Autopilot de GKE o Standard con un contenedor que ejecuta TGI.

Esta guía es un buen punto de partida si necesitas el control detallado, la escalabilidad, la resiliencia, la portabilidad y la rentabilidad de Kubernetes administrado cuando implementas y entregas tus cargas de trabajo de IA/AA. Si necesitas una plataforma de IA administrada unificada para compilar y entregar modelos de AA con rapidez de forma rentable, te recomendamos que pruebes nuestra solución de implementación de Vertex AI.

Formación

La entrega de Gemma mediante GPU en GKE con TGIte permite implementar una solución de entrega de inferencia sólida y lista para la producción con todos los beneficios de administrarKubernetes, incluida la escalabilidad eficiente y la mayor disponibilidad. En esta sección, se describen las tecnologías clave que se usan en este instructivo.

Gemma

Gemma es un conjunto de modelos de Inteligencia Artificial (IA) generativos básicos disponibles de forma abierta que se lanzaron con una licencia abierta. Estos modelos de IA están disponibles para ejecutarse en tus aplicaciones, hardware, dispositivos móviles o servicios alojados.

En esta guía, presentamos los siguientes modelos:

Gemma para la generación de texto, también puedes ajustar estos modelos para especializarlos en realizar tareas específicas.
CodeGemma es una colección de modelos potentes y ligeros que pueden realizar una variedad de tareas de codificación, como la finalización de código por medio de la finalización, la generación de código, la comprensión del lenguaje natural, el razonamiento matemático y las instrucciones que se detallan a continuación.

Para obtener más información, consulta la documentación de Gemma.

GPU

Las GPUs te permiten acelerar cargas de trabajo específicas que se ejecutan en tus nodos, como el aprendizaje automático y el procesamiento de datos. GKE proporciona una variedad de opciones de tipos de máquinas para la configuración de nodos, incluidos los tipos de máquinas con GPUs NVIDIA H100, L4 y A100.

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

Obtén información sobre la disponibilidad actual de la versión de GPU.
Obtén información sobre las GPUs en GKE.

Inferencia de generación de texto (TGI)

TGI es el kit de herramientas de Hugging Face para implementar y entregar LLM. TGI permite la generación de texto de alto rendimiento para LLM de código abierto populares, incluido Gemma. La TGI incluye características como las siguientes:

Implementación optimizada de transformadores con Atención en flash y PagedAttention
Agrupación en lotes continua para mejorar la capacidad de procesamiento general de la entrega
Paralelismo de tensor para una inferencia más rápida en varias GPU

Para obtener más información, consulta la documentación de TGI.

Objetivos

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 que estén interesados en el uso de las capacidades de organización de contenedores de Kubernetes para entregar LLMs en hardware de GPU H100, A100 y L4.

Al final de esta guía, deberías poder realizar los siguientes pasos:

Preparar tu entorno con un clúster de GKE en modo Autopilot.
Implementar TGI en tu clúster.
Usar TGI para entregar el modelo de Gemma 2B o 7B a través de curl y una interfaz de chat web.

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.

Crea una cuenta de Hugging Face, si todavía no la tienes.
Asegúrate de que tu proyecto tenga la cuota suficiente para las GPU. Para obtener más información, consulta Acerca de las GPU y Cuotas de asignación.

Obtén acceso al modelo

Para obtener acceso a los modelos de Gemma para la implementación en GKE, primero debes firmar el contrato de consentimiento de licencia y, luego, generar un token de acceso de Hugging Face.

Debes firmar el acuerdo de consentimiento para usar Gemma. Sigue estas instrucciones:

Accede a la página de consentimiento del modelo en Kaggle.com.
Verifica el consentimiento con tu cuenta de Hugging Face.
Acepta los términos del modelo.

Genera un token de acceso

Para acceder al modelo a través de Hugging Face, necesitarás un token de Hugging Face.

Sigue estos pasos para generar un token nuevo si aún no tienes uno:

Haz clic en Tu perfil > Configuración > Tokens de acceso.
Selecciona Token nuevo.
Especifica el nombre que desees y un rol de al menos Read.
Selecciona Genera un token.
Copia el token generado al portapapeles.

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 REGION=REGION
export CLUSTER_NAME=tgi
export HF_TOKEN=HF_TOKEN
```
Reemplaza los siguientes valores:
- PROJECT_ID: El ID del proyecto de Google Cloud.
- REGION: Una región que admita el tipo de acelerador que deseas usar, por ejemplo, us-central1 para la GPU L4.
- HF_TOKEN: El token de Hugging Face que generaste antes.

Crea y configura recursos de Google Cloud

Sigue estas instrucciones para crear los recursos necesarios.

Crea un clúster de GKE y un grupo de nodos

Puedes entregar Gemma en GPU en un clúster de GKE Autopilot o Standard. Te recomendamos que uses un clúster de 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

En Cloud Shell, ejecuta el siguiente comando:

gcloud container clusters create-auto ${CLUSTER_NAME} \
  --project=${PROJECT_ID} \
  --region=${REGION} \
  --release-channel=rapid \
  --cluster-version=1.28

GKE crea un clúster de Autopilot con nodos de CPU y GPU según lo solicitan las cargas de trabajo implementadas.

Estándar

En Cloud Shell, ejecuta el siguiente comando para crear un clúster estándar:

gcloud container clusters create ${CLUSTER_NAME} \
  --project=${PROJECT_ID} \
  --region=${REGION} \
  --workload-pool=${PROJECT_ID}.svc.id.goog \
  --release-channel=rapid \
  --num-nodes=1

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

Ejecuta el siguiente comando para crear un grupo de nodos para el clúster:

gcloud container node-pools create gpupool \
  --accelerator type=nvidia-l4,count=2,gpu-driver-version=latest \
  --project=${PROJECT_ID} \
  --location=${REGION} \
  --node-locations=${REGION}-a \
  --cluster=${CLUSTER_NAME} \
  --machine-type=g2-standard-24 \
  --num-nodes=1

GKE crea un solo grupo de nodos que contiene dos GPU L4 para cada nodo.

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 de Kubernetes que contenga el token de Hugging Face:

kubectl create secret generic hf-secret \
  --from-literal=hf_api_token=${HF_TOKEN} \
  --dry-run=client -o yaml | kubectl apply -f -

Implementa TGI

En esta sección, implementarás el contenedor de TGI para entregar el modelo de Gemma que deseas usar. Para obtener información sobre los modelos ajustados y previamente entrenados por instrucciones y cuál seleccionar para tu caso de uso, consulta Modelos ajustados.

Implementa un modelo de Gemma ajustado a instrucciones

Sigue estas instrucciones si deseas implementar un modelo o una variante de Gemma ajustados a instrucciones.

Gemma 2B-it

Sigue estas instrucciones para implementar el modelo ajustado por instrucciones de Gemma 2B.

Crea el siguiente manifiesto tgi-2b-it.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: tgi-gemma-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gemma-server
  template:
    metadata:
      labels:
        app: gemma-server
        ai.gke.io/model: gemma-2b-it
        ai.gke.io/inference-server: text-generation-inference
        examples.ai.gke.io/source: user-guide
    spec:
      containers:
      - name: inference-server
        image: ghcr.io/huggingface/text-generation-inference:2.0.2
        resources:
          requests:
            cpu: "2"
            memory: "7Gi"
            ephemeral-storage: "20Gi"
            nvidia.com/gpu: 1
          limits:
            cpu: "2"
            memory: "7Gi"
            ephemeral-storage: "20Gi"
            nvidia.com/gpu: 1
        args:
        - --model-id=$(MODEL_ID)
        - --num-shard=1
        env:
        - name: MODEL_ID
          value: google/gemma-2b-it
        - name: PORT
          value: "8000"
        - name: HUGGING_FACE_HUB_TOKEN
          valueFrom:
            secretKeyRef:
              name: hf-secret
              key: hf_api_token
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
      volumes:
      - name: dshm
        emptyDir:
          medium: Memory
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-l4
---
apiVersion: v1
kind: Service
metadata:
  name: llm-service
spec:
  selector:
    app: gemma-server
  type: ClusterIP
  ports:
  - protocol: TCP
    port: 8000
    targetPort: 8000

Aplica el manifiesto
```
kubectl apply -f tgi-2b-it.yaml
```

Gemma 7B-it

Sigue estas instrucciones para implementar el modelo ajustado por instrucciones de Gemma 7B.

Crea el siguiente manifiesto tgi-7b-it.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: tgi-gemma-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gemma-server
  template:
    metadata:
      labels:
        app: gemma-server
        ai.gke.io/model: gemma-7b-it
        ai.gke.io/inference-server: text-generation-inference
        examples.ai.gke.io/source: user-guide
    spec:
      containers:
      - name: inference-server
        image: ghcr.io/huggingface/text-generation-inference:2.0.2
        resources:
          requests:
            cpu: "2"
            memory: "25Gi"
            ephemeral-storage: "40Gi"
            nvidia.com/gpu: 2
          limits:
            cpu: "10"
            memory: "25Gi"
            ephemeral-storage: "40Gi"
            nvidia.com/gpu: 2
        args:
        - --model-id=$(MODEL_ID)
        - --num-shard=2
        env:
        - name: MODEL_ID
          value: google/gemma-7b-it
        - name: PORT
          value: "8000"
        - name: HUGGING_FACE_HUB_TOKEN
          valueFrom:
            secretKeyRef:
              name: hf-secret
              key: hf_api_token
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
      volumes:
      - name: dshm
        emptyDir:
          medium: Memory
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-l4
---
apiVersion: v1
kind: Service
metadata:
  name: llm-service
spec:
  selector:
    app: gemma-server
  type: ClusterIP
  ports:
    - protocol: TCP
      port: 8000
      targetPort: 8000

Aplica el manifiesto
```
kubectl apply -f tgi-7b-it.yaml
```

CodeGemma 7B-it

Sigue estas instrucciones para implementar el modelo ajustado por instrucciones de CodeGemma 7B.

Crea el siguiente manifiesto tgi-codegemma-1.1-7b-it.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: tgi-gemma-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gemma-server
  template:
    metadata:
      labels:
        app: gemma-server
        ai.gke.io/model: codegemma-1.1-7b-it
        ai.gke.io/inference-server: text-generation-inference
        examples.ai.gke.io/source: user-guide
    spec:
      containers:
      - name: inference-server
        image: ghcr.io/huggingface/text-generation-inference:2.0.2
        resources:
          requests:
            cpu: "2"
            memory: "25Gi"
            ephemeral-storage: "40Gi"
            nvidia.com/gpu: 2
          limits:
            cpu: "10"
            memory: "25Gi"
            ephemeral-storage: "40Gi"
            nvidia.com/gpu: 2
        args:
        - --model-id=$(MODEL_ID)
        - --num-shard=2
        env:
        - name: MODEL_ID
          value: google/codegemma-1.1-7b-it
        - name: PORT
          value: "8000"
        - name: HUGGING_FACE_HUB_TOKEN
          valueFrom:
            secretKeyRef:
              name: hf-secret
              key: hf_api_token
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
      volumes:
      - name: dshm
        emptyDir:
          medium: Memory
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-l4
---
apiVersion: v1
kind: Service
metadata:
  name: llm-service
spec:
  selector:
    app: gemma-server
  type: ClusterIP
  ports:
    - protocol: TCP
      port: 8000
      targetPort: 8000

Aplica el manifiesto

kubectl apply -f tgi-codegemma-1.1-7b-it.yaml

Implementa un modelo de Gemma previamente entrenado

Sigue estas instrucciones si deseas implementar un modelo o una variante de Gemma previamente entrenados.

Gemma 2B

Sigue estas instrucciones para implementar el modelo previamente entrenado de Gemma 2B.

Crea el siguiente manifiesto tgi-2b.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: tgi-gemma-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gemma-server
  template:
    metadata:
      labels:
        app: gemma-server
        ai.gke.io/model: gemma-2b
        ai.gke.io/inference-server: text-generation-inference
        examples.ai.gke.io/source: user-guide
    spec:
      containers:
      - name: inference-server
        image: ghcr.io/huggingface/text-generation-inference:2.0.2
        resources:
          requests:
            cpu: "2"
            memory: "7Gi"
            ephemeral-storage: "20Gi"
            nvidia.com/gpu: 1
          limits:
            cpu: "2"
            memory: "7Gi"
            ephemeral-storage: "20Gi"
            nvidia.com/gpu: 1
        args:
        - --model-id=$(MODEL_ID)
        - --num-shard=1
        env:
        - name: MODEL_ID
          value: google/gemma-2b
        - name: PORT
          value: "8000"
        - name: HUGGING_FACE_HUB_TOKEN
          valueFrom:
            secretKeyRef:
              name: hf-secret
              key: hf_api_token
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
      volumes:
      - name: dshm
        emptyDir:
          medium: Memory
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-l4
---
apiVersion: v1
kind: Service
metadata:
  name: llm-service
spec:
  selector:
    app: gemma-server
  type: ClusterIP
  ports:
  - protocol: TCP
    port: 8000
    targetPort: 8000

Aplica el manifiesto
```
kubectl apply -f tgi-2b.yaml
```

Gemma 7B

Sigue estas instrucciones para implementar el modelo previamente entrenado de Gemma 2B.

Crea el siguiente manifiesto tgi-7b.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: tgi-gemma-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gemma-server
  template:
    metadata:
      labels:
        app: gemma-server
        ai.gke.io/model: gemma-7b
        ai.gke.io/inference-server: text-generation-inference
        examples.ai.gke.io/source: user-guide
    spec:
      containers:
      - name: inference-server
        image: ghcr.io/huggingface/text-generation-inference:2.0.2
        resources:
          requests:
            cpu: "2"
            memory: "25Gi"
            ephemeral-storage: "40Gi"
            nvidia.com/gpu: 2
          limits:
            cpu: "10"
            memory: "25Gi"
            ephemeral-storage: "40Gi"
            nvidia.com/gpu: 2
        args:
        - --model-id=$(MODEL_ID)
        - --num-shard=2
        env:
        - name: MODEL_ID
          value: google/gemma-7b
        - name: PORT
          value: "8000"
        - name: HUGGING_FACE_HUB_TOKEN
          valueFrom:
            secretKeyRef:
              name: hf-secret
              key: hf_api_token
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
      volumes:
      - name: dshm
        emptyDir:
          medium: Memory
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-l4
---
apiVersion: v1
kind: Service
metadata:
  name: llm-service
spec:
  selector:
    app: gemma-server
  type: ClusterIP
  ports:
    - protocol: TCP
      port: 8000
      targetPort: 8000

Aplica el manifiesto
```
kubectl apply -f tgi-7b.yaml
```

CodeGemma 2B

Sigue estas instrucciones para implementar el modelo previamente entrenado de CodeGemma 2B.

Crea el siguiente manifiesto tgi-codegemma-1.1-2b.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: tgi-gemma-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gemma-server
  template:
    metadata:
      labels:
        app: gemma-server
        ai.gke.io/model: codegemma-1.1-2b
        ai.gke.io/inference-server: text-generation-inference
        examples.ai.gke.io/source: user-guide
    spec:
      containers:
      - name: inference-server
        image: ghcr.io/huggingface/text-generation-inference:2.0.2
        resources:
          requests:
            cpu: "2"
            memory: "7Gi"
            ephemeral-storage: "20Gi"
            nvidia.com/gpu: 1
          limits:
            cpu: "2"
            memory: "7Gi"
            ephemeral-storage: "20Gi"
            nvidia.com/gpu: 1
        args:
        - --model-id=$(MODEL_ID)
        - --num-shard=1
        env:
        - name: MODEL_ID
          value: google/codegemma-1.1-2b
        - name: PORT
          value: "8000"
        - name: HUGGING_FACE_HUB_TOKEN
          valueFrom:
            secretKeyRef:
              name: hf-secret
              key: hf_api_token
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
      volumes:
      - name: dshm
        emptyDir:
          medium: Memory
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-l4
---
apiVersion: v1
kind: Service
metadata:
  name: llm-service
spec:
  selector:
    app: gemma-server
  type: ClusterIP
  ports:
  - protocol: TCP
    port: 8000
    targetPort: 8000

Aplica el manifiesto

kubectl apply -f tgi-codegemma-1.1-2b.yaml

Un Pod en el clúster descarga los pesos del modelo de Hugging Face y, luego, inicia el motor de entrega.

Espera a que la implementación esté disponible:

kubectl wait --for=condition=Available --timeout=700s deployment/tgi-gemma-deployment

Observa los registros de la implementación en ejecución:

kubectl logs -f -l app=gemma-server

El recurso de implementación descarga los datos del modelo. Este proceso puede demorar unos minutos. El resultado es similar al siguiente:

2024-05-08T20:27:37.557836Z  INFO text_generation_router: router/src/main.rs:317: Warming up model
2024-05-08T20:27:39.206371Z  INFO text_generation_launcher: Cuda Graphs are enabled for sizes [1, 2, 4, 8, 16, 32]
2024-05-08T20:27:40.461998Z  INFO text_generation_router: router/src/main.rs:354: Setting max batch total tokens to 632992
2024-05-08T20:27:40.462018Z  INFO text_generation_router: router/src/main.rs:355: Connected
2024-05-08T20:27:40.462025Z  WARN text_generation_router: router/src/main.rs:369: Invalid hostname, defaulting to 0.0.0.0

Asegúrate de que el modelo se haya descargado por completo antes de continuar con la siguiente sección.

Entrega el modelo

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

Configura la redirección de puertos

Ejecuta el siguiente comando para configurar la redirección de puertos al modelo:

kubectl port-forward service/llm-service 8000:8000

El resultado es similar al siguiente:

Forwarding from 127.0.0.1:8000 -> 8000

Interactúa con el modelo con curl

En esta sección, se muestra cómo puedes realizar una prueba de humo básica para verificar los modelos implementados previamente entrenados o los ajustados por instrucciones. Para simplificar, en esta sección se describe el enfoque de prueba con los modelos Gemma 2B previamente entrenados, Gemma 2B ajustados a las instrucciones y los modelos de CodeGemma 7B con instrucciones ajustadas.

Gemma 2B

En una sesión de terminal nueva, usa curl para chatear con tu modelo:

USER_PROMPT="Java is a"

curl -X POST http://localhost:8000/generate \
  -H "Content-Type: application/json" \
  -d @- <<EOF
{
    "inputs": "${USER_PROMPT}",
    "parameters": {
        "temperature": 0.90,
        "top_p": 0.95,
        "max_new_tokens": 128
    }
}
EOF

En el siguiente resultado, se muestra un ejemplo de la respuesta del modelo:

{"generated_text":" general-purpose, high-level, class-based, object-oriented programming language. <strong>Is Java a statically typed language?</strong> Yes, Java is a statically typed language. Java also supports dynamic typing. Static typing means that the type of every variable is explicitly specified at the time of declaration. The type can be either implicit or explicit. Static typing means that if no types are assigned then it will be assumed as a primitive type.\n\n<h3>What is Java?</h3>\n\nJava is a general-purpose, class-based, object-oriented programming language. Java is one of the oldest programming languages that has gained a"}

Gemma 2B-it

En una sesión de terminal nueva, usa curl para chatear con tu modelo:

USER_PROMPT="I'm new to coding. If you could only recommend one programming language to start with, what would it be and why?"

curl -X POST http://localhost:8000/generate \
  -H "Content-Type: application/json" \
  -d @- <<EOF
{
    "inputs": "<start_of_turn>user\n${USER_PROMPT}<end_of_turn>\n",
    "parameters": {
        "temperature": 0.90,
        "top_p": 0.95,
        "max_new_tokens": 128
    }
}
EOF

En el siguiente resultado, se muestra un ejemplo de la respuesta del modelo:

{"generated_text":"**Python**\n\n**Reasons why Python is a great choice for beginners:**\n\n* **Simple syntax:** Python uses clear and concise syntax, making it easy for beginners to pick up.\n* **Easy to learn:** Python's syntax is based on English, making it easier to learn than other languages.\n* **Large and supportive community:** Python has a massive and active community of developers who are constantly willing to help.\n* **Numerous libraries and tools:** Python comes with a vast collection of libraries and tools that make it easy to perform various tasks, such as data manipulation, web development, and machine learning.\n* **"}

CodeGemma

En una sesión de terminal nueva, usa curl para chatear con tu modelo:

USER_PROMPT="Generate a python code example of a adding two numbers from a function called addNumbers"

curl -s -X POST http://localhost:8000/generate \
  -H "Content-Type: application/json" \
  -d @- <<EOF | jq -r .generated_text
{
    "inputs": "<start_of_turn>user\n${USER_PROMPT}<end_of_turn>\n",
    "parameters": {
        "temperature": 0.90,
        "top_p": 0.95,
        "max_new_tokens": 2000
    }
}
EOF

En el siguiente resultado, se muestra un ejemplo de la respuesta del modelo:

def addNumbers(num1, num2):
  sum = num1 + num2
  return sum

# Get the input from the user
num1 = float(input("Enter the first number: "))
num2 = float(input("Enter the second number: "))

# Call the addNumbers function
sum = addNumbers(num1, num2)

# Print the result
print("The sum of", num1, "and", num2, "is", sum)

Interactúa con el modelo a través de una interfaz de chat de Gradio (opcional)

En esta sección, compilarás una aplicación de chat web que te permita interactuar con el modelo ajustado a instrucciones. Para simplificar, en esta sección solo se describe el enfoque de prueba con el modelo 2B-it.

Gradio es una biblioteca de Python que tiene un wrapper ChatInterface de ChatInterface que crea interfaces de usuario para chatbots.

Implementa la interfaz de chat

En Cloud Shell, guarda el siguiente manifiesto YAML como gradio.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: gradio
  labels:
    app: gradio
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gradio
  template:
    metadata:
      labels:
        app: gradio
    spec:
      containers:
      - name: gradio
        image: us-docker.pkg.dev/google-samples/containers/gke/gradio-app:v1.0.3
        resources:
          requests:
            cpu: "250m"
            memory: "512Mi"
          limits:
            cpu: "500m"
            memory: "512Mi"
        env:
        - name: CONTEXT_PATH
          value: "/generate"
        - name: HOST
          value: "http://llm-service:8000"
        - name: LLM_ENGINE
          value: "tgi"
        - name: MODEL_ID
          value: "gemma"
        - name: USER_PROMPT
          value: "<start_of_turn>user\nprompt<end_of_turn>\n"
        - name: SYSTEM_PROMPT
          value: "<start_of_turn>model\nprompt<end_of_turn>\n"
        ports:
        - containerPort: 7860
---
apiVersion: v1
kind: Service
metadata:
  name: gradio
spec:
  selector:
    app: gradio
  ports:
    - protocol: TCP
      port: 8080
      targetPort: 7860
  type: ClusterIP

Aplica el manifiesto
```
kubectl apply -f gradio.yaml
```

Espera a que la implementación esté disponible:

kubectl wait --for=condition=Available --timeout=300s deployment/gradio

Usa la interfaz de chat

En Cloud Shell, ejecuta el siguiente comando:
```
kubectl port-forward service/gradio 8080:8080
```
Esto crea una redirección de puertos desde Cloud Shell al servicio de Gradio.
Haz clic en el botón Vista previa en la Web, que se encuentra en la parte superior derecha de la barra de tareas de Cloud Shell. Haga clic en Vista previa en el puerto 8080. Se abrirá una pestaña nueva en el navegador.
Interactúa con Gemma con la interfaz de chat de Gradio. Agrega un mensaje y haz clic en Enviar.

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.

Limpia

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 el siguiente comando:

gcloud container clusters delete ${CLUSTER_NAME} \
  --region=${REGION}

¿Qué sigue?

Obtén más información sobre las GPUs en GKE.
Para aprender a usar Gemma con TGI en otros aceleradores, incluidas las GPU A100 y H100, visualiza el código de muestra en GitHub.
Aprende a implementar cargas de trabajo de GPUs en Autopilot.
Aprende a implementar cargas de trabajo de GPUs en Standard.
Explora la documentación de TGI.
Explora Vertex AI Model Garden.
Descubre cómo ejecutar cargas de trabajo de IA/AA optimizadas con las capacidades de organización de la plataforma de GKE.

Entrega modelos abiertos de Gemma mediante GPUs en GKE con Hugging Face TGI

Formación

Gemma

GPU

Inferencia de generación de texto (TGI)

Objetivos

Antes de comenzar

Check for the roles

Grant the roles

Obtén acceso al modelo

Firma el acuerdo de consentimiento de licencia

Genera un token de acceso

Prepare el entorno

Crea y configura recursos de Google Cloud

Crea un clúster de GKE y un grupo de nodos

Autopilot

Estándar

Crea un secreto de Kubernetes para las credenciales de Hugging Face

Implementa TGI

Implementa un modelo de Gemma ajustado a instrucciones

Gemma 2B-it

Gemma 7B-it

CodeGemma 7B-it

Implementa un modelo de Gemma previamente entrenado

Gemma 2B

Gemma 7B

CodeGemma 2B

Entrega el modelo

Configura la redirección de puertos

Interactúa con el modelo con curl

Gemma 2B

Gemma 2B-it

CodeGemma

Interactúa con el modelo a través de una interfaz de chat de Gradio (opcional)

Implementa la interfaz de chat

Usa la interfaz de chat

Soluciona problemas

Limpia

Borra los recursos implementados

¿Qué sigue?