En este instructivo, se muestra cómo implementar y entregar modelos de lenguaje grandes (LLM) con GPUs en Google Kubernetes Engine (GKE) con el framework de entrega de Inferencia de generación de texto (TGI) de Hugging Face. En este instructivo, se proporcionan los conceptos básicos para comprender y explorar la implementación práctica de LLM para la inferencia en un entorno de Kubernetes administrado. Implementarás en GKE un contenedor precompilado que ejecuta TGI. También configurarás GKE para cargar las ponderaciones de Gemma 2B, 9B y 27B desde Hugging Face.
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 las capacidades de organización de contenedores de Kubernetes para entregar LLMs en hardware de GPU H100, A100 y L4. 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.
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.
Antes de leer esta página, asegúrate de estar familiarizado con lo siguiente:
Fondo
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 que se especialicen en realizar tareas específicas.
- CodeGemma es una colección de modelos potentes y ligeros que pueden realizar una variedad de tareas de programación, como completar código en el medio, generar código, comprender el lenguaje natural, razonar matemáticamente y seguir instrucciones.
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.
Inferencia de generación de texto (TGI)
TGI es el kit de herramientas de Hugging Face para implementar y entregar LLMs. TGI permite la generación de texto de alto rendimiento para los LLM de código abierto populares, incluido Gemma. El TGI incluye funciones como las siguientes:
- Implementación optimizada de transformadores con Flash Attention 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 GPUs
Para obtener más información, consulta la documentación de la TGI.
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.
Firma el acuerdo de consentimiento de licencia
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.
Prepara 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:
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 .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 CONTROL_PLANE_LOCATION=CONTROL_PLANE_LOCATION export CLUSTER_NAME=CLUSTER_NAME export HF_TOKEN=HF_TOKENReemplaza los siguientes valores:
PROJECT_ID: Tu Google Cloud ID del proyecto.CONTROL_PLANE_LOCATION: La región de Compute Engine del plano de control de tu clúster. Esta región debe admitir el tipo de acelerador que deseas usar, por ejemplo,us-central1para la GPU L4.CLUSTER_NAME: El nombre de tu clúster.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, ejecute el siguiente comando:
gcloud container clusters create-auto CLUSTER_NAME \
--project=PROJECT_ID \
--location=CONTROL_PLANE_LOCATION \
--release-channel=rapid
Reemplaza los siguientes valores:
PROJECT_ID: Tu Google Cloud ID del proyecto.CONTROL_PLANE_LOCATION: La región de Compute Engine del plano de control de tu clúster. Esta región debe admitir el tipo de acelerador que deseas usar, por ejemplo,us-central1para la GPU L4.CLUSTER_NAME: El nombre de tu clúster.
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 \ --location=CONTROL_PLANE_LOCATION \ --workload-pool=PROJECT_ID.svc.id.goog \ --release-channel=rapid \ --num-nodes=1Reemplaza los siguientes valores:
PROJECT_ID: Tu Google Cloud ID del proyecto.CONTROL_PLANE_LOCATION: La región de Compute Engine del plano de control de tu clúster. Esta región debe admitir el tipo de acelerador que deseas usar, por ejemplo,us-central1para la GPU L4.CLUSTER_NAME: El nombre de tu clúster.
La creación del clúster puede tomar varios minutos.
Para crear un grupo de nodos para tu clúster con el tamaño de disco adecuado, ejecuta el siguiente comando:
Gemma 2 2B
gcloud container node-pools create gpupool \ --accelerator type=nvidia-l4,count=1,gpu-driver-version=latest \ --project=PROJECT_ID \ --location=CONTROL_PLANE_LOCATION \ --node-locations=CONTROL_PLANE_LOCATION-a \ --cluster=CLUSTER_NAME \ --machine-type=g2-standard-8 \ --num-nodes=1GKE crea un grupo de nodos único que contiene una GPU L4 para cada nodo.
Gemma 2 9B
gcloud container node-pools create gpupool \ --accelerator type=nvidia-l4,count=2,gpu-driver-version=latest \ --project=PROJECT_ID \ --location=CONTROL_PLANE_LOCATION \ --node-locations=CONTROL_PLANE_LOCATION-a \ --cluster=CLUSTER_NAME \ --machine-type=g2-standard-24 \ --num-nodes=1GKE crea un solo grupo de nodos que contiene dos GPU L4 para cada nodo.
Gemma 2 27B
gcloud container node-pools create gpupool \ --accelerator type=nvidia-l4,count=4,gpu-driver-version=latest \ --project=PROJECT_ID \ --location=CONTROL_PLANE_LOCATION \ --node-locations=CONTROL_PLANE_LOCATION-a \ --cluster=CLUSTER_NAME \ --machine-type=g2-standard-48 \ --num-nodes=1 \ --disk-size=180GKE crea un solo grupo de nodos que contiene cuatro GPU L4 para cada nodo.
Crea un secreto de Kubernetes para las credenciales de Hugging Face
En Cloud Shell, haz lo siguiente:
Configura
kubectlpara comunicarse con tu clúster:gcloud container clusters get-credentials CLUSTER_NAME \ --location=CONTROL_PLANE_LOCATIONCrea 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 -Reemplaza
HF_TOKENpor el token de Hugging Face que generaste antes.
Implementa TGI
En esta sección, implementarás el contenedor de TGI para entregar el modelo de Gemma que deseas usar. Para implementar el modelo, 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.
Gemma 2 2B-it
Sigue estas instrucciones para implementar el modelo ajustado por instrucciones de Gemma 2B.
Crea el siguiente manifiesto
tgi-2-2b-it.yaml:Aplica el manifiesto
kubectl apply -f tgi-2-2b-it.yaml
Gemma 2 9B-it
Sigue estas instrucciones para implementar el modelo ajustado por instrucciones de Gemma 9B.
Crea el siguiente manifiesto
tgi-2-9b-it.yaml:Aplica el manifiesto
kubectl apply -f tgi-2-9b-it.yaml
Gemma 2 27B-it
Sigue estas instrucciones para implementar el modelo ajustado por instrucciones de Gemma 2 27B
Crea el siguiente manifiesto
tgi-2-27b-it.yaml:Aplica el manifiesto
kubectl apply -f tgi-2-27b-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:Aplica el manifiesto
kubectl apply -f tgi-codegemma-1.1-7b-it.yaml
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 2 ajustado por instrucciones y CodeGemma.
Gemma 2
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
El resultado 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
El resultado 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:Aplica el manifiesto
kubectl apply -f gradio.yamlEspera 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:8080Esto 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 mensajeConnected, que indica que el modelo está listo para entregar. - Si ves
Connection refused, verifica que tu redirección de puertos esté activa.
Observa el rendimiento del modelo
Para observar el rendimiento del modelo, puedes usar la integración del panel de TGI 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 TGI, debes habilitar Google Cloud Managed Service para Prometheus, que recopila las métricas de TGI, en tu clúster de GKE. De forma predeterminada, TGI expone las métricas en formato Prometheus, por lo que no es necesario instalar un exportador adicional.
Luego, puedes ver las métricas con el panel de TGI. Si deseas obtener información para usar Google Cloud Managed Service para Prometheus y recopilar métricas de tu modelo, consulta la guía de observabilidad de TGI en la documentación de Cloud Monitoring.