Ajusta los modelos abiertos de Gemma con varias GPU en GKE

En este instructivo, se muestra cómo ajustar el modelo de lenguaje grande (LLM) Gemma, la familia de modelos abiertos, con unidades de procesamiento gráfico (GPU) en Google Kubernetes Engine (GKE) con la biblioteca Transformers de Hugging Face. El ajuste fino es un proceso de aprendizaje supervisado que mejora la capacidad de un modelo previamente entrenado para realizar tareas específicas mediante la actualización de sus parámetros con un conjunto de datos nuevo. En este instructivo, descargarás los modelos de la familia Gemma previamente entrenados con 2B parámetros de Hugging Face y los ajustarás en un clúster de GKE Autopilot o Standard.

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 ajustas un LLM.

Práctica recomendada:

Prueba nuestra solución de Vertex AI si necesitas una plataforma de IA administrada unificada para compilar y entregar modelos de AA con rapidez de forma rentable.

Fondo

La entrega de Gemma mediante GPU en GKE con la biblioteca Transformers permite implementar una solución de entrega de inferencia sólida y lista para 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 Gemma para la generación de texto. También puedes ajustar estos modelos para que se especialicen en realizar tareas específicas.

El conjunto de datos que usas en este documento es b-mc2/sql-create-context.

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:

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

Transformers de Hugging Face

Con la biblioteca Transformers de Hugging Face, puedes acceder a modelos previamente entrenados de vanguardia. La biblioteca de Transformers te permite reducir el tiempo, los recursos y los costos computacionales asociados con el entrenamiento completo del modelo.

En este instructivo, usarás las APIs y herramientas de Hugging Face para descargar y ajustar estos modelos previamente entrenados.

Objetivos

Esta guía está dirigida a usuarios nuevos o existentes de GKE, ingenieros de AA, ingenieros de MLOps (DevOps) o administradores de plataformas que estén interesados en usar las funciones de organización de contenedores de Kubernetes para ajustar LLMs en hardware de GPU H100, A100 y L4.

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

  1. Preparar tu entorno con un clúster de GKE en modo Autopilot.
  2. Crea un contenedor de ajuste.
  3. Usa GPUs para ajustar el modelo Gemma 2B y subirlo a Hugging Face.

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.

    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.

    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

    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.

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

      1. Accede a la página de consentimiento del modelo en Kaggle.com.
      2. Verifica el consentimiento con tu cuenta de Hugging Face.
      3. 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:

      1. Haz clic en Tu perfil > Configuración > Tokens de acceso.
      2. Selecciona Token nuevo.
      3. Especifica el nombre que desees y un rol de al menos Write.
      4. Selecciona Genera un token.
      5. 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:

      1. En la Google Cloud consola, haz clic en Ícono de activación de Cloud Shell 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
export PROJECT_ID=$(gcloud config get project)
export CONTROL_PLANE_LOCATION=CONTROL_PLANE_LOCATION
export CLUSTER_NAME=CLUSTER_NAME
export HF_TOKEN=HF_TOKEN
export HF_PROFILE=HF_PROFILE

        Reemplaza los siguientes valores:

        • PROJECT_ID: Es el ID de tu proyecto. Google Cloud
        • CONTROL_PLANE_LOCATION: La región de Compute Engine del plano de control de tu clúster. Proporciona una región que admita el tipo de acelerador que deseas usar, por ejemplo, us-central1 para las GPUs L4.
        • CLUSTER_NAME: El nombre de tu clúster.
        • HF_TOKEN: El token de Hugging Face que generaste antes.
        • HF_PROFILE: El ID del perfil de Hugging Face que creaste antes.

      3. Clona el repositorio de código de muestra de GitHub:

        git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples
cd kubernetes-engine-samples/ai-ml/llm-finetuning-gemma

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

      Práctica recomendada:

      Usa Autopilot para una experiencia de Kubernetes completamente administrada.

      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 \
    --cluster-version=1.29

      Reemplaza los siguientes valores:

      • PROJECT_ID: Es el ID de tu proyecto. Google Cloud
      • CONTROL_PLANE_LOCATION: La región de Compute Engine del plano de control de tu clúster. Proporciona una región que admita el tipo de acelerador que deseas usar, por ejemplo, us-central1 para las GPUs 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

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

        Reemplaza los siguientes valores:

        • PROJECT_ID: Es el ID de tu proyecto. Google Cloud
        • CONTROL_PLANE_LOCATION: La región de Compute Engine del plano de control de tu clúster. Proporciona una región que admita el tipo de acelerador que deseas usar, por ejemplo, us-central1 para las GPUs L4.
        • CLUSTER_NAME: El nombre de tu clúster.

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

      2. 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=8,gpu-driver-version=latest \
    --project=PROJECT_ID \
    --location=CONTROL_PLANE_LOCATION \
    --node-locations=CONTROL_PLANE_LOCATION-a \
    --cluster=CLUSTER_NAME \
    --machine-type=g2-standard-96 \
    --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:

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

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

        Reemplaza los siguientes valores:

        • CONTROL_PLANE_LOCATION: La región de Compute Engine del plano de control de tu clúster.
        • CLUSTER_NAME: El nombre de tu clúster.

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

        Reemplaza $HF_TOKEN por el token de Hugging Face que generaste antes o usa la variable de entorno si la configuraste.

      Crea un contenedor de ajuste con Docker y Cloud Build

      Este contenedor usa el código de PyTorch y Hugging Face Transformers para ajustar el modelo de Gemma existente previamente entrenado.

      1. Crea un repositorio de Docker de Artifact Registry:

        gcloud artifacts repositories create gemma \
    --project=PROJECT_ID \
    --repository-format=docker \
    --location=us \
    --description="Gemma Repo"

        Reemplaza PROJECT_ID por el ID del proyecto de Google Cloud.

      2. Compila y envía la imagen:

        gcloud builds submit .

      3. Exporta el IMAGE_URL para usarlo más adelante en este instructivo.

        export IMAGE_URL=us-docker.pkg.dev/PROJECT_ID/gemma/finetune-gemma-gpu:1.0.0

      Ejecuta un trabajo de ajuste en GKE

      En esta sección, implementarás el trabajo de ajuste de Gemma. Un controlador de Job en Kubernetes crea uno o más Pods y garantiza que ejecuten correctamente una tarea específica.

      1. Abre el archivo finetune.yaml.

        apiVersion: batch/v1
kind: Job
metadata:
  name: finetune-job
  namespace: default
spec:
  backoffLimit: 2
  template:
    metadata:
      annotations:
        kubectl.kubernetes.io/default-container: finetuner
    spec:
      terminationGracePeriodSeconds: 600
      containers:
      - name: finetuner
        image: $IMAGE_URL
        resources:
          limits:
            nvidia.com/gpu: "8"
        env:
        - name: MODEL_NAME
          value: "google/gemma-2b"
        - name: NEW_MODEL
          value: "gemma-2b-sql-finetuned"
        - name: LORA_R
          value: "8"
        - name: LORA_ALPHA
          value: "16"
        - name: TRAIN_BATCH_SIZE
          value: "1"
        - name: EVAL_BATCH_SIZE
          value: "2"
        - name: GRADIENT_ACCUMULATION_STEPS
          value: "2"
        - name: DATASET_LIMIT
          value: "1000"
        - name: MAX_SEQ_LENGTH
          value: "512"
        - name: LOGGING_STEPS
          value: "5"
        - name: HF_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
      restartPolicy: OnFailure

      2. Aplica el manifiesto para crear el trabajo de ajuste:

        envsubst < finetune.yaml | kubectl apply -f -

        Esta instrucción reemplaza IMAGE_URL por la variable en el manifiesto.

      3. Actualiza el trabajo a través de la ejecución del siguiente comando:

        watch kubectl get pods

      4. Ejecuta el siguiente comando para verificar los registros del trabajo:

        kubectl logs job.batch/finetune-job -f

        El recurso de trabajo descarga los datos del modelo y, luego, ajusta el modelo en las ocho GPUs. Este proceso puede tardar hasta 20 minutos.

      5. Una vez que se complete el trabajo, ve a tu cuenta de Hugging Face. Aparecerá un modelo nuevo llamado HF_PROFILE/gemma-2b-sql-finetuned en tu perfil de Hugging Face.

      Entrega el modelo más preciso en GKE

      En esta sección, implementarás el contenedor vLLM JetStream para entregar el modelo de Gemma. En este instructivo, se usa una implementación de Kubernetes para implementar el contenedor vLLM. 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.

      1. Crea el siguiente manifiesto serve-gemma.yaml:

        apiVersion: apps/v1
kind: Deployment
metadata:
  name: vllm-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: vllm
        examples.ai.gke.io/source: user-guide
    spec:
      containers:
      - name: inference-server
        image: docker.io/vllm/vllm-openai:v0.10.0
        resources:
          requests:
            cpu: "2"
            memory: "7Gi"
            ephemeral-storage: "10Gi"
            nvidia.com/gpu: 1
          limits:
            cpu: "2"
            memory: "7Gi"
            ephemeral-storage: "10Gi"
            nvidia.com/gpu: 1
        command: ["python3", "-m", "vllm.entrypoints.openai.api_server"]
        args:
        - --model=$(MODEL_ID)
        - --tensor-parallel-size=1
        env:
        - name: LD_LIBRARY_PATH
          value: ${LD_LIBRARY_PATH}:/usr/local/nvidia/lib64
        - name: MODEL_ID
          value: google/gemma-2b
        - 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

      2. Crea la variable de entorno para el nuevo MODEL_ID:

        export MODEL_ID=HF_PROFILE/gemma-2b-sql-finetuned

        Reemplaza HF_PROFILE por el ID del perfil de Hugging Face que creaste antes.

      3. Reemplaza MODEL_ID en el manifiesto:

        sed -i "s|google/gemma-2b|$MODEL_ID|g" serve-gemma.yaml

      4. Aplica el manifiesto

        kubectl apply -f serve-gemma.yaml

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

      5. Espera a que la implementación esté disponible:

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

      6. 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 a este:

      INFO 01-26 19:02:54 model_runner.py:689] Graph capturing finished in 4 secs.
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)

      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

      Una vez implementado el modelo, 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 a este:

      Forwarding from 127.0.0.1:8000 -> 8000

      Interactúa con el modelo con curl

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

      El siguiente comando de ejemplo es para TGI:

      USER_PROMPT="Question: What is the total number of attendees with age over 30 at kubecon eu? Context: CREATE TABLE attendees (name VARCHAR, age INTEGER, kubecon VARCHAR)"

curl -X POST http://localhost:8000/generate \
  -H "Content-Type: application/json" \
  -d @- <<EOF
{
    "prompt": "${USER_PROMPT}",
    "temperature": 0.1,
    "top_p": 1.0,
    "max_tokens": 24
}
EOF

      El resultado muestra un ejemplo de la respuesta del modelo.

      {"generated_text":" Answer: SELECT COUNT(age) FROM attendees WHERE age > 30 AND kubecon = 'eu'\n"}

      Según tu consulta, es posible que debas cambiar el max_token para obtener un mejor resultado. También puedes usar el modelo ajustado por instrucción para mejorar la experiencia de chat.

      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 apliquen cargos a tu cuenta de Google Cloud por los recursos que creaste en esta guía, ejecuta el siguiente comando:

      gcloud container clusters delete CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION

      Reemplaza los siguientes valores:

      • CONTROL_PLANE_LOCATION: La región de Compute Engine del plano de control de tu clúster. Proporciona una región que admita el tipo de acelerador que deseas usar, por ejemplo, us-central1 para las GPUs L4.
      • CLUSTER_NAME: El nombre de tu clúster.

      ¿Qué sigue?