Google utiliza tecnología de IA para traducir contenido a tu idioma preferido. Las traducciones realizadas con IA pueden contener errores.

Ajusta Gemma 4 en un clúster de GKE A4 de varios hosts

GPUs en clúster

En este instructivo, se muestra cómo ajustar un Gemma 4 31B (google/gemma-4-31b-it) en un clúster de Autopilot de Google Kubernetes Engine (GKE) de varias máquinas y varias GPUs Google Cloud. Este clúster usa dos instancias de máquina virtual (VM) A4 (a4-highgpu-8g) con un total de 16 GPUs NVIDIA B200.

Los tres procesos principales que se describen en este instructivo son los siguientes:

Implementa un clúster de GKE de varias máquinas en modo Autopilot.
Compila una imagen de contenedor personalizada con las dependencias de ajuste necesarias mediante Cloud Build.
Organiza una carga de trabajo de ajuste distribuida de varias máquinas en las 16 GPUs con Kubernetes JobSet y la biblioteca Hugging Face Accelerate con Fully Sharded Data Parallel v2 (FSDP v2), y envía puntos de control a Hugging Face Hub.

Este instructivo está dirigido a ingenieros de aprendizaje automático (AA), investigadores, administradores y operadores de plataformas, y especialistas en datos y en IA que implementan clústeres de GKE en Google Cloud para ajustar LLMs en varias máquinas.

Objetivos

Accede al modelo de Gemma 4 con Hugging Face.
Prepara el entorno.
Crea y, luego, implementa un clúster de GKE A4 de varias máquinas.
Ajusta el modelo de Gemma 4 31B en 16 GPUs con Kubernetes JobSet y Hugging Face Accelerate con FSDP v2.
Supervisa tu trabajo
Consulta las ponderaciones de adaptación ajustadas en Hugging Face Hub.
Realiza una limpieza

Costos

En este documento, usarás los siguientes componentes facturables de Google Cloud:

Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios.

Es posible que los usuarios Google Cloud nuevos decumplan con los requisitos para acceder a una prueba gratuita.

Antes de comenzar

Si quieres obtener los permisos que necesitas para completar este instructivo, pídele a tu administrador que te otorgue los siguientes roles de IAM en tu proyecto:

Administrador de Kubernetes Engine (roles/container.admin)
Administrador de Compute (roles/compute.admin)
Administrador de almacenamiento (roles/storage.admin)
Administrador de Artifact Registry (roles/artifactregistry.admin)
Editor de Cloud Build (roles/cloudbuild.builds.editor)
Usuario de la cuenta de servicio (roles/iam.serviceAccountUser)
Administrador de cuenta de servicio (roles/iam.serviceAccountAdmin)
Administrador de IAM de proyecto (roles/resourcemanager.projectIamAdmin)
Administrador de Service Usage (roles/serviceusage.serviceUsageAdmin)

Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

También puedes obtener los permisos necesarios mediante roles personalizados o cualquier otro rol predefinido.

Instala e inicializa Google Cloud CLI y, luego, instala kubectl. Si usas Cloud Shell, ambas herramientas están preinstaladas.
Habilita las APIs requeridas, si aún no están habilitadas:

Roles necesarios para habilitar las APIs
Para habilitar las APIs, necesitas el permiso serviceusage.services.enable. Si creaste el proyecto, es probable que ya tengas este permiso a través del rol de propietario (roles/owner). De lo contrario, puedes obtener este permiso a través del rol de administrador de Service Usage (roles/serviceusage.serviceUsageAdmin). Obtén información para otorgar roles.
```
gcloud services enable compute.googleapis.com container.googleapis.com artifactregistry.googleapis.com cloudbuild.googleapis.com logging.googleapis.com cloudresourcemanager.googleapis.com servicenetworking.googleapis.com
```

Habilita la cuenta de servicio predeterminada de Compute Engine para tu Google Cloud proyecto:

export PROJECT_NUMBER="$(gcloud projects describe "YOUR_PROJECT_ID" --format "value(project_number)")"
gcloud iam service-accounts enable "${PROJECT_NUMBER}-compute@developer.gserviceaccount.com" \
    --project=YOUR_PROJECT_ID

Otorga los roles de IAM con menos privilegios que necesita la cuenta de servicio predeterminada de Compute Engine para compilar la imagen de contenedor y ejecutar la carga de trabajo de ajuste:
```
ROLES=(
  "roles/artifactregistry.writer"
  "roles/cloudbuild.builds.builder"
  "roles/logging.logWriter"
  "roles/monitoring.metricWriter"
  "roles/monitoring.viewer"
  "roles/stackdriver.resourceMetadata.writer"
  "roles/storage.objectViewer"
)
for role in "${ROLES[@]}"; do
  gcloud projects add-iam-policy-binding YOUR_PROJECT_ID \
      --member="serviceAccount:${PROJECT_NUMBER}-compute@developer.gserviceaccount.com" \
      --role="${role}" 1>/dev/null
done
unset ROLES
```
Nota: En este paso, solo se otorgan los roles predefinidos que requiere este instructivo. Otorgar un rol básico, como Editor (roles/editor), le da a la cuenta de servicio muchos más permisos de los que necesita, y las políticas de tu organización podrían bloquear la concesión. Si deseas obtener más información, consulta Prácticas recomendadas para trabajar con cuentas de servicio.

Verifica que se hayan otorgado los roles a la cuenta de servicio predeterminada de Compute Engine:

echo "Displaying roles for ${PROJECT_NUMBER}-compute@developer.gserviceaccount.com:"
gcloud projects get-iam-policy YOUR_PROJECT_ID \
    --flatten="bindings[].members" \
    --filter="bindings.members:serviceAccount:${PROJECT_NUMBER}-compute@developer.gserviceaccount.com" \
    --format="table(bindings.role)"

Crea credenciales de autenticación locales para tu cuenta de usuario:
```
gcloud auth application-default login
```
Nota: Si usas un shell local y un proveedor de identidad (IdP) externo, y encuentras un error de autenticación después de ejecutar el comando anterior, accede a la gcloud CLI con tu identidad federada.

Habilita el Acceso al SO para tu proyecto:

gcloud compute project-info add-metadata \
    --metadata=enable-oslogin=TRUE \
    --project=YOUR_PROJECT_ID

Accede a Gemma 4 con Hugging Face

Para usar Hugging Face para acceder a Gemma 4, completa los siguientes pasos:

Accede a Hugging Face y acepta el acuerdo de licencia de Gemma 4.
Crea un token de acceso write de Hugging Face.
Haz clic en Tu perfil > Configuración > Tokens de acceso > +Crear token nuevo.
Copia y guarda el valor del token de acceso write. Usarás este token para descargar el modelo base y enviar puntos de control de adaptación ajustados a Hugging Face Hub antes de que GKE reduzca los nodos de GPU.

Prepara el entorno

Para preparar el entorno, configura las siguientes variables de entorno:

export PROJECT_ID="YOUR_PROJECT_ID"
export CLUSTER_NAME="YOUR_CLUSTER_NAME"
export CLUSTER_REGION="YOUR_REGION"
export RESERVATION="YOUR_RESERVATION_NAME"
export HF_TOKEN="YOUR_HF_TOKEN"
export ARTIFACT_REPO_LOCATION="YOUR_ARTIFACT_REGISTRY_LOCATION"
export NUM_NODES="YOUR_NUMBER_OF_NODES"

gcloud config set project "${PROJECT_ID}"
gcloud config set billing/quota_project "${PROJECT_ID}"

Reemplaza lo siguiente:

YOUR_PROJECT_ID: Es el ID del Google Cloud proyecto en el que deseas crear el clúster de GKE.
YOUR_CLUSTER_NAME: Es el nombre del clúster de GKE que se creará. Este nombre debe tener 40 caracteres o menos y estar compuesto por caracteres alfanuméricos en minúscula y guiones.
YOUR_REGION: Es la región en la que deseas crear tu clúster de GKE. Solo puedes crear el clúster en la región en la que existe tu reserva.
YOUR_RESERVATION_NAME: Es el identificador de tu capacidad reservada.
YOUR_HF_TOKEN: Es el token de acceso write de Hugging Face que creaste en la sección anterior.
YOUR_ARTIFACT_REGISTRY_LOCATION: Es la Google Cloud región (por ejemplo, us-central1) en la que deseas crear tu repositorio de Artifact Registry. Para minimizar la latencia de extracción de imágenes, usa la misma región que tú especificaste para YOUR_REGION.
YOUR_NUMBER_OF_NODES: Es la cantidad de nodos de VM A4 en tu trabajo de ajuste. Para este instructivo de varias máquinas con 16 GPUs NVIDIA B200 en dos instancias a4-highgpu-8g, establece este valor en 2.

Crea un clúster de GKE de varias máquinas en modo Autopilot

Crea un clúster de GKE de varias máquinas en modo Autopilot:

gcloud container clusters create-auto "${CLUSTER_NAME}" \
    --project="${PROJECT_ID}" \
    --location="${CLUSTER_REGION}"

La creación del clúster de GKE puede tardar varios minutos en completarse. Para verificar que Google Cloud haya terminado de crear tu clúster, ve a Clústeres de Kubernetes en la consola de Google Cloud .

Configura kubectl para comunicarse con tu clúster de GKE

Configura kubectl para comunicarse con tu clúster de GKE:

gcloud container clusters get-credentials "${CLUSTER_NAME}" \
    --location="${CLUSTER_REGION}"

Crea un secreto de Kubernetes para las credenciales de Hugging Face

Crea un secreto de Kubernetes para almacenar tu 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 -

Prepara tu carga de trabajo

Para preparar tu carga de trabajo, haz lo siguiente:

Crea secuencias de comandos de carga de trabajo.
Usa Docker y Cloud Build para crear un contenedor de ajuste.

Crea secuencias de comandos de carga de trabajo

Para crear los archivos de configuración y las secuencias de comandos que usa tu carga de trabajo de ajuste, completa los siguientes pasos:

Crea un directorio para las secuencias de comandos de carga de trabajo. Usa este directorio como tu directorio de trabajo.
```
mkdir llm-finetuning-gemma
cd llm-finetuning-gemma
```

Crea el archivo cloudbuild.yaml para compilar la imagen de contenedor de carga de trabajo con Cloud Build y enviarla a Artifact Registry:

steps:
- name: 'gcr.io/cloud-builders/docker'
  args:
  - 'build'
  - '-t'
  - '$_ARTIFACT_REPO_LOCATION-docker.pkg.dev/$PROJECT_ID/gemma/finetune-gemma-multihost-gpu:2.0.0'
  - '.'
images:
- '$_ARTIFACT_REPO_LOCATION-docker.pkg.dev/$PROJECT_ID/gemma/finetune-gemma-multihost-gpu:2.0.0'
options:
  logging: CLOUD_LOGGING_ONLY

Crea un archivo Dockerfile para definir el entorno y, luego, instalar las dependencias necesarias para completar el trabajo de ajuste:

FROM nvidia/cuda:12.8.1-cudnn-devel-ubuntu24.04
RUN apt-get update && \
    apt-get -y install python3 python3-dev gcc python3-pip \
        python3-venv git curl vim && \
    rm -rf /var/lib/apt/lists/*
RUN python3 -m venv /opt/venv
ENV PATH="/opt/venv/bin:/usr/local/nvidia/bin:$PATH"
ENV LD_LIBRARY_PATH="/usr/local/nvidia/lib64:$LD_LIBRARY_PATH"
RUN pip3 install setuptools wheel packaging ninja
RUN pip3 install torch torchvision torchaudio \
    --index-url https://download.pytorch.org/whl/cu128
RUN pip3 install \
    "transformers>=5.5.0" \
    trl==0.29.1 \
    peft==0.18.1 \
    accelerate==1.13.0 \
    bitsandbytes==0.49.2 \
    datasets==4.8.4 \
    evaluate==0.4.5 \
    tensorboard==2.20.0 \
    protobuf==6.31.1 \
    sentencepiece==0.2.0
WORKDIR /workspace
COPY finetune.py /workspace/finetune.py
COPY accel_fsdp_gemma4_config.yaml /workspace/accel_fsdp_gemma4_config.yaml
CMD ["accelerate", "launch", "--config_file", "/workspace/accel_fsdp_gemma4_config.yaml", "/workspace/finetune.py"]

Crea el archivo accel_fsdp_gemma4_config.yaml. Esta configuración dirige Hugging Face Accelerate para fragmentar Gemma4TextDecoderLayer en 16 GPUs en dos máquinas con FSDP v2:

compute_environment: LOCAL_MACHINE
debug: false
distributed_type: FSDP
downcast_bf16: 'no'
enable_cpu_affinity: false
fsdp_config:
  fsdp_activation_checkpointing: false
  fsdp_auto_wrap_policy: TRANSFORMER_BASED_WRAP
  fsdp_cpu_ram_efficient_loading: false
  fsdp_offload_params: true
  fsdp_reshard_after_forward: true
  fsdp_state_dict_type: FULL_STATE_DICT
  fsdp_transformer_layer_cls_to_wrap: Gemma4TextDecoderLayer
  fsdp_version: 2
machine_rank: 0
main_training_function: main
mixed_precision: bf16
num_machines: 2
num_processes: 16
rdzv_backend: static
same_network: true
tpu_env: []
tpu_use_cluster: false
tpu_use_sudo: false
use_cpu: false

Crea el manifiesto JobSet de Kubernetes finetune.yaml:

apiVersion: resource.k8s.io/v1
kind: ResourceClaimTemplate
metadata:
  name: mrdma
spec:
  spec:
    devices:
      requests:
      - name: mrdma
        exactly:
          deviceClassName: mrdma.google.com
---
apiVersion: jobset.x-k8s.io/v1alpha2
kind: JobSet
metadata:
  name: finetune-jobset
  namespace: default
spec:
  failurePolicy:
    maxRestarts: 2
  replicatedJobs:
  - name: workers
    replicas: 1
    template:
      spec:
        parallelism: ${NUM_NODES}
        completions: ${NUM_NODES}
        backoffLimit: 0
        template:
          metadata:
            annotations:
              kubectl.kubernetes.io/default-container: finetuner
          spec:
            terminationGracePeriodSeconds: 600
            restartPolicy: OnFailure
            nodeSelector:
              cloud.google.com/compute-class: "Accelerator"
              cloud.google.com/gke-accelerator: "nvidia-b200"
              cloud.google.com/reservation-name: ${RESERVATION}
              cloud.google.com/reservation-affinity: "specific"
              cloud.google.com/gke-gpu-driver-version: latest
            containers:
            - name: finetuner
              image: $IMAGE_URL
              command: ["bash", "-c"]
              args:
              - |
                NUM_PROCESSES=$(( ${NUM_NODES} * 8 ))
                accelerate launch \
                  --config_file /workspace/accel_fsdp_gemma4_config.yaml \
                  --num_machines ${NUM_NODES} \
                  --num_processes ${NUM_PROCESSES} \
                  --machine_rank ${JOB_COMPLETION_INDEX} \
                  --main_process_ip finetune-jobset-workers-0-0.finetune-jobset.default.svc.cluster.local \
                  --main_process_port 29500 \
                  /workspace/finetune.py \
                  --base_model google/gemma-4-31b-it \
                  --new_model gemma-31b-text-to-sql \
                  --per_device_train_batch_size 4 \
                  --gradient_accumulation_steps 4 \
                  --num_train_epochs 3 \
                  --learning_rate 1e-5 \
                  --save_strategy steps \
                  --save_steps 15 \
                  --push_to_hub
              resources:
                limits:
                  nvidia.com/gpu: "8"
                  memory: "1000Gi"
                  ephemeral-storage: "350Gi"
                requests:
                  nvidia.com/gpu: "8"
                  memory: "1000Gi"
                  ephemeral-storage: "350Gi"
              env:
              - name: HF_TOKEN
                valueFrom:
                  secretKeyRef:
                    name: hf-secret
                    key: hf_api_token
              - name: NUM_NODES
                value: "${NUM_NODES}"
              volumeMounts:
              - mountPath: /dev/shm
                name: dshm
            volumes:
            - name: dshm
              emptyDir:
                medium: Memory
                sizeLimit: 64Gi

Crea la secuencia de comandos de ajuste supervisado finetune.py:

import argparse
import torch
from datasets import load_dataset
from huggingface_hub import login
from peft import LoraConfig
from transformers import AutoConfig, AutoModelForCausalLM, AutoTokenizer
from trl import SFTConfig, SFTTrainer


def get_args():
    def str2bool(v):
        if isinstance(v, bool):
            return v
        return v.lower() in ("yes", "true", "t", "1")

    parser = argparse.ArgumentParser()
    parser.add_argument(
        "--base_model",
        "--model_id",
        dest="base_model",
        type=str,
        default="google/gemma-4-31b-it",
        help="Hugging Face model ID",
    )
    parser.add_argument(
        "--hf_token",
        type=str,
        default=None,
        help="Hugging Face token for gated models and Hub uploads",
    )
    parser.add_argument(
        "--trust_remote",
        type=str2bool,
        default=False,
        help="Trust remote code when loading tokenizer",
    )
    parser.add_argument(
        "--use_fast",
        type=str2bool,
        default=True,
        help="Determines if a fast Rust-based tokenizer should be used",
    )
    parser.add_argument(
        "--dataset_name",
        type=str,
        default="philschmid/gretel-synthetic-text-to-sql",
        help="Hugging Face dataset name",
    )
    parser.add_argument(
        "--new_model",
        "--output_dir",
        dest="new_model",
        type=str,
        default="gemma-31b-text-to-sql",
        help="Directory and repository name to save model checkpoints",
    )

    # LoRA arguments
    parser.add_argument(
        "--lora_r", type=int, default=16, help="LoRA attention dimension"
    )
    parser.add_argument(
        "--lora_alpha", type=int, default=32, help="LoRA alpha scaling factor"
    )
    parser.add_argument(
        "--lora_dropout",
        type=float,
        default=0.05,
        help="LoRA dropout probability",
    )
    # SFTConfig arguments
    parser.add_argument(
        "--max_length",
        type=int,
        default=1024,
        help="Maximum sequence length",
    )
    parser.add_argument(
        "--num_train_epochs",
        type=int,
        default=3,
        help="Number of training epochs",
    )
    parser.add_argument(
        "--per_device_train_batch_size",
        type=int,
        default=4,
        help="Batch size per device during training",
    )
    parser.add_argument(
        "--gradient_accumulation_steps",
        type=int,
        default=4,
        help="Gradient accumulation steps",
    )
    parser.add_argument(
        "--learning_rate", type=float, default=1e-5, help="Learning rate"
    )
    parser.add_argument(
        "--logging_steps", type=int, default=10, help="Log every X steps"
    )
    parser.add_argument(
        "--save_strategy",
        type=str,
        default="steps",
        help="Checkpoint save strategy",
    )
    parser.add_argument(
        "--save_steps",
        type=int,
        default=15,
        help="Save checkpoint every X steps",
    )
    parser.add_argument(
        "--push_to_hub",
        action="store_true",
        help="Push model back up to Hugging Face Hub",
    )
    parser.add_argument(
        "--hub_private_repo",
        type=str2bool,
        default=True,
        help="Push to a private repository on Hugging Face Hub",
    )
    return parser.parse_args()


def main():
    args = get_args()
    # --- 1. Setup and Login ---
    if args.hf_token:
        login(args.hf_token)
    # --- 2. Create and prepare the fine-tuning dataset ---
    dataset = load_dataset(args.dataset_name, split="train")
    dataset = dataset.shuffle().select(range(12500))
    dataset = dataset.train_test_split(test_size=2500 / 12500)
    # --- 3. Configure Model and Tokenizer ---
    if torch.cuda.is_available() and torch.cuda.get_device_capability()[0] >= 8:
        torch_dtype_obj = torch.bfloat16
    else:
        torch_dtype_obj = torch.float16
    tokenizer = AutoTokenizer.from_pretrained(
        args.base_model,
        trust_remote_code=args.trust_remote,
        use_fast=args.use_fast,
    )
    if tokenizer.pad_token is None:
        tokenizer.pad_token = tokenizer.eos_token

    # --- 4. Define the Formatting Function ---
    def formatting_func(example):
        system_message = (
            "You are a text to SQL query translator. Users will ask you "
            "questions in English and you will generate a SQL query based "
            "on the provided SCHEMA."
        )
        user_prompt = (
            "Given the <USER_QUERY> and the <SCHEMA>, generate the "
            "corresponding SQL command to retrieve the desired data, "
            "considering the query's syntax, semantics, and schema "
            "constraints.\n\n<SCHEMA>\n{context}\n</SCHEMA>\n\n"
            "<USER_QUERY>\n{question}\n</USER_QUERY>\n"
        )

        messages = [
            {"role": "system", "content": system_message},
            {
                "role": "user",
                "content": user_prompt.format(
                    question=example["sql_prompt"],
                    context=example["sql_context"],
                ),
            },
            {"role": "assistant", "content": example["sql"]},
        ]
        return tokenizer.apply_chat_template(messages, tokenize=False)

    # --- 5. Load Model and Configure LoRA ---
    config = AutoConfig.from_pretrained(args.base_model)
    config.use_cache = False
    print("Loading base model...")
    model = AutoModelForCausalLM.from_pretrained(
        args.base_model,
        config=config,
        attn_implementation="sdpa",
        torch_dtype=torch_dtype_obj,
    )

    peft_config = LoraConfig(
        lora_alpha=args.lora_alpha,
        lora_dropout=args.lora_dropout,
        r=args.lora_r,
        bias="none",
        target_modules=[
            "q_proj",
            "k_proj",
            "v_proj",
            "o_proj",
            "gate_proj",
            "up_proj",
            "down_proj",
        ],
        exclude_modules=r".*(vision_tower|embed_vision|audio_tower|embed_audio).*",
        task_type="CAUSAL_LM",
    )
    # --- 6. Configure Training Arguments ---
    training_args = SFTConfig(
        output_dir=args.new_model,
        max_length=args.max_length,
        num_train_epochs=args.num_train_epochs,
        per_device_train_batch_size=args.per_device_train_batch_size,
        gradient_accumulation_steps=args.gradient_accumulation_steps,
        learning_rate=args.learning_rate,
        logging_steps=args.logging_steps,
        save_strategy=args.save_strategy,
        save_steps=args.save_steps,
        packing=False,
        label_names=["domain"],
        gradient_checkpointing=True,
        gradient_checkpointing_kwargs={"use_reentrant": False},
        optim="adamw_torch",
        fp16=torch_dtype_obj == torch.float16,
        bf16=torch_dtype_obj == torch.bfloat16,
        max_grad_norm=0.3,
        warmup_steps=0.03,
        lr_scheduler_type="constant",
        push_to_hub=args.push_to_hub,
        hub_private_repo=args.hub_private_repo,
        report_to="tensorboard",
    )
    # --- 7. Create Trainer and Start Training ---
    trainer = SFTTrainer(
        model=model,
        args=training_args,
        peft_config=peft_config,
        train_dataset=dataset["train"],
        eval_dataset=dataset["test"],
        processing_class=tokenizer,
        formatting_func=formatting_func,
    )
    print("Starting training...")
    trainer.train()
    print("Training finished.")
    # --- 8. Save the final model ---
    print(f"Saving final model to {args.new_model}")
    if trainer.is_fsdp_enabled:
        trainer.accelerator.state.fsdp_plugin.set_state_dict_type(
            "FULL_STATE_DICT"
        )
    trainer.save_model(args.new_model)
    if torch.distributed.is_initialized():
        torch.distributed.destroy_process_group()


if __name__ == "__main__":
    main()

Usa Docker y Cloud Build para crear un contenedor de ajuste

Crea un repositorio de Docker de Artifact Registry:

gcloud artifacts repositories create gemma \
    --repository-format=docker \
    --location="${ARTIFACT_REPO_LOCATION}" \
    --description="Repository for Gemma fine tuning workload containers" || true

Instala las definiciones de recursos personalizados (CRD) JobSet necesarias para organizar cargas de trabajo de varias máquinas:

kubectl apply --server-side \
    -f https://github.com/kubernetes-sigs/jobset/releases/download/v0.12.0/manifests.yaml

# Wait for JobSet controller webhook to become ready to prevent intermittent failures during deploy
kubectl rollout status deployment/jobset-controller-manager -n jobset-system --timeout=600s

En el directorio llm-finetuning-gemma que creaste en un paso anterior, envía la compilación del contenedor a Cloud Build:
```
gcloud builds submit . \
    --substitutions=_ARTIFACT_REPO_LOCATION="${ARTIFACT_REPO_LOCATION}"
```
Nota: La compilación y el envío de la imagen de contenedor de CUDA y PyTorch tardan aproximadamente 20 minutos en completarse. Debido a que cloudbuild.yaml establece logging: CLOUD_LOGGING_ONLY, el comando genera un vínculo (Logs are available at [...]) que puedes abrir en la Google Cloud consola de para supervisar el progreso de la compilación en tiempo real.
Exporta la URL de la imagen de contenedor de varias máquinas. La usarás en un paso posterior de este instructivo, cuando implementes el manifiesto JobSet:
```
IMAGE_REGISTRY="${ARTIFACT_REPO_LOCATION}-docker.pkg.dev/${PROJECT_ID}"
export IMAGE_URL="${IMAGE_REGISTRY}/gemma/finetune-gemma-multihost-gpu:2.0.0"
```

Inicia tu carga de trabajo de ajuste

Para implementar y supervisar tu carga de trabajo de ajuste distribuida, completa los siguientes pasos:

Sustituye las variables de entorno en el manifiesto de ajuste para crear el trabajo de ajuste:
```
envsubst '${RESERVATION} ${IMAGE_URL} ${NUM_NODES}' < finetune.yaml \
    | kubectl apply -f -
```
Debido a que tu clúster se ejecuta en el modo Autopilot de GKE, puede tardar unos minutos en aprovisionar los dos nodos A4 habilitados para GPU y extraer la imagen de contenedor.
Observa los pods de trabajador hasta que ambos pasen al estado Running:
```
watch kubectl get pods
```
Después de que los pods de trabajador pasen a Running, transmite los registros de entrenamiento:
```
kubectl logs -l "job-name=finetune-jobset-workers-0" -f
```
Nota: kubectl logs solo genera registros de entrenamiento después de que los pods de trabajador ingresan al estado Running. Cada trabajador descarga las ponderaciones del modelo de Gemma 4 31B (esto tarda aproximadamente cinco minutos) y, luego, ejecuta el ajuste distribuido de FSDP v2 en las 16 GPUs. Los puntos de control se guardan cada 15 pasos y se suben automáticamente a tu repositorio privado de Hugging Face Hub en https://huggingface.co/YOUR_HF_USERNAME/gemma-31b-text-to-sql.

Supervisa tu carga de trabajo

Puedes supervisar el uso de la GPU en tu clúster de GKE para verificar que las 16 GPUs en ambas máquinas A4 procesen de forma activa los pasos de entrenamiento. Genera y abre el vínculo de observabilidad en tu navegador:

echo "https://console.cloud.google.com/kubernetes/clusters/details/${CLUSTER_REGION}/${CLUSTER_NAME}/observability?mods=monitoring_api_prod&project=${PROJECT_ID}&pageState=(\"timeRange\":(\"duration\":\"PT1H\"),\"nav\":(\"section\":\"gpu\"),\"groupBy\":(\"groupByType\":\"namespacesTop5\"))"

Cuando supervises tu carga de trabajo, espera el siguiente comportamiento:

Uso de la GPU: Para un trabajo de ajuste distribuido correcto, puedes esperar ver que el uso de la GPU en las 16 GPUs NVIDIA B200 aumente y se estabilice cerca del 95% al 100% durante los pasos de entrenamiento.
Duración del trabajo: En dos nodos a4-highgpu-8g (16 GPUs B200), el trabajo de ajuste de 3 épocas tarda aproximadamente 2 horas y media en completarse.

Consulta las ponderaciones de adaptación ajustadas

Cuando finalice el entrenamiento, consulta las ponderaciones y los puntos de control de adaptación de LoRA ajustados en Hugging Face Hub en https://huggingface.co/YOUR_HF_USERNAME/gemma-31b-text-to-sql.

Limpia

Para evitar que se generen cargos adicionales, borra los recursos creados durante este instructivo.

Borra tus recursos

Borra el JobSet de ajuste:
```
kubectl delete jobset finetune-jobset
```

Borra tu clúster de GKE:

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

Borra tu repositorio de Artifact Registry:

gcloud artifacts repositories delete gemma \
    --location="${ARTIFACT_REPO_LOCATION}" \
    --quiet