O Google usa tecnologia de IA na tradução de conteúdos para seu idioma de preferência. As traduções com IA podem ter erros.

Ajustar o Gemma 4 em um cluster do GKE A4 de vários hosts

GPUs em cluster

Este tutorial mostra como ajustar um Gemma 4 31B (google/gemma-4-31b-it) em um cluster do Google Kubernetes Engine (GKE) Autopilot de vários hosts e várias GPUs Google Cloud. Esse cluster usa duas instâncias de máquina virtual (VM) A4 (a4-highgpu-8g) com um total de 16 GPUs NVIDIA B200.

Os três principais processos descritos neste tutorial são os seguintes:

Implante um cluster do GKE de vários hosts no modo Autopilot.
Crie uma imagem de contêiner personalizada com as dependências de ajuste fino necessárias usando o Cloud Build.
Orquestre uma carga de trabalho de ajuste fino distribuída em vários hosts em todas as 16 GPUs usando o JobSet do Kubernetes e a biblioteca Accelerate do Hugging Face com o Fully Sharded Data Parallel v2 (FSDP v2), enviando checkpoints para o Hugging Face Hub.

Este tutorial é destinado a engenheiros de machine learning (ML), pesquisadores, administradores e operadores de plataforma e especialistas em dados e IA que implantam clusters do GKE em Google Cloud para ajustar LLMs em vários hosts.

Objetivos

Acesse o modelo Gemma 4 usando o Hugging Face.
Prepare o ambiente.
Crie e implante um cluster do GKE A4 de vários hosts.
Ajuste o modelo Gemma 4 31B em 16 GPUs usando o JobSet do Kubernetes e o Hugging Face Accelerate com o FSDP v2.
Monitore o job.
Confira os pesos do adaptador ajustado no Hugging Face Hub.
Fazer a limpeza.

Custos

Neste documento, você usará os seguintes componentes faturáveis do Google Cloud:

Para gerar uma estimativa de custo baseada na projeção de uso, use a calculadora de preços.

Novos usuários do Google Cloud podem estar qualificados para um teste sem custo financeiro.

Antes de começar

Para conseguir as permissões que você precisa para concluir este tutorial, peça ao administrador para conceder a você os seguintes papéis do IAM no seu projeto:

Administrador do Kubernetes Engine (roles/container.admin)
Administrador do Compute (roles/compute.admin)
Administrador do Storage (roles/storage.admin)
Administrador do Artifact Registry (roles/artifactregistry.admin)
Editor do Cloud Build (roles/cloudbuild.builds.editor)
Usuário da conta de serviço (roles/iam.serviceAccountUser)
Administrador da conta de serviço (roles/iam.serviceAccountAdmin)
Administrador do IAM do projeto (roles/resourcemanager.projectIamAdmin)
Administrador do Service Usage (roles/serviceusage.serviceUsageAdmin)

Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Também é possível conseguir as permissões necessárias com papéis personalizados ou outros papéis predefinidos.

Instale e inicialize a Google Cloud CLI e instale kubectl. Se você usa o Cloud Shell, as duas ferramentas já estão instaladas.
Ative as APIs necessárias, se alguma ainda não estiver ativada:

Funções necessárias para ativar APIs
Para ativar as APIs, é necessário ter a permissão serviceusage.services.enable. Se você criou o projeto, provavelmente já tem essa permissão pelo papel Proprietário (roles/owner). Caso contrário, você pode receber essa permissão pelo papel Administrador do Service Usage (roles/serviceusage.serviceUsageAdmin). Saiba como conceder papéis.
```
gcloud services enable compute.googleapis.com container.googleapis.com artifactregistry.googleapis.com cloudbuild.googleapis.com logging.googleapis.com cloudresourcemanager.googleapis.com servicenetworking.googleapis.com
```

Ative a conta de serviço padrão do Compute Engine para seu Google Cloud projeto:

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

Conceda os papéis do IAM de menor privilégio que a conta de serviço padrão do Compute Engine precisa para criar a imagem do contêiner e executar a carga de trabalho de ajuste fino:
```
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
```
Observação: esta etapa concede apenas os papéis predefinidos necessários para este tutorial Conceder um papel básico, como Editor (roles/editor), dá à conta de serviço muito mais permissões do que ela precisa, e as políticas da sua organização podem bloquear a concessão. Para mais informações, consulte Práticas recomendadas para trabalhar com contas de serviço.

Verifique se os papéis foram concedidos à conta de serviço padrão do 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)"

Crie credenciais de autenticação local para sua conta de usuário:
```
gcloud auth application-default login
```
Observação: se você usa um shell local e um provedor de identidade (IdP) externo e encontra um erro de autenticação após executar o comando anterior, faça login na CLI gcloud com sua identidade federada.

Ative o Login do SO para seu projeto:

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

Acessar o Gemma 4 usando o Hugging Face

Para usar o Hugging Face para acessar o Gemma 4, siga estas etapas:

Faça login no Hugging Face e aceite o contrato de licença do Gemma 4.
Crie um token de acesso write do Hugging Face.
Clique em Seu perfil > Configurações > Tokens de acesso > +Criar novo token.
Copie e salve o valor do token de acesso write. Você usa esse token para fazer o download do modelo base e enviar checkpoints do adaptador ajustado para o Hugging Face Hub antes que o GKE reduza os nós da GPU.

Preparar o ambiente

Para preparar o ambiente, defina as seguintes variáveis de ambiente:

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

Substitua:

YOUR_PROJECT_ID: o ID do Google Cloud projeto em que você quer criar o cluster do GKE.
YOUR_CLUSTER_NAME: o nome do cluster do GKE a ser criado. Esse nome precisa ter 40 caracteres ou menos e ser composto de caracteres alfanuméricos minúsculos e hífens.
YOUR_REGION: a região em que você quer criar o cluster do GKE. Só é possível criar o cluster na região em que a reserva existe.
YOUR_RESERVATION_NAME: o identificador da capacidade reservada.
YOUR_HF_TOKEN: o token de acesso do Hugging Face write que você criou na seção anterior.
YOUR_ARTIFACT_REGISTRY_LOCATION: a Google Cloud região (por exemplo, us-central1) em que você quer criar o repositório do Artifact Registry. Para minimizar a latência de extração de imagens, use a mesma região que você especificou para YOUR_REGION.
YOUR_NUMBER_OF_NODES: o número de nós de VM A4 no seu job de ajuste fino. Para este tutorial de vários hosts com 16 GPUs NVIDIA B200 em duas instâncias a4-highgpu-8g, defina esse valor como 2.

Criar um cluster do GKE de vários hosts no modo Autopilot

Crie um cluster do GKE de vários hosts no modo Autopilot:

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

A criação do cluster do GKE pode levar vários minutos para ser concluída. Para verificar se o Google Cloud cluster foi criado, acesse Clusters do Kubernetes no Google Cloud console.

Configurar o kubectl para se comunicar com o cluster do GKE

Configure kubectl para se comunicar com o cluster do GKE:

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

Criar um secret do Kubernetes para as credenciais do Hugging Face

Crie um secret do Kubernetes para armazenar o token do Hugging Face:

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

Preparar sua carga de trabalho

Para preparar sua carga de trabalho, faça o seguinte:

Crie scripts de carga de trabalho.
Use o Docker e o Cloud Build para criar um contêiner de ajuste fino.

Criar scripts de carga de trabalho

Para criar os arquivos de configuração e scripts usados pela carga de trabalho de ajuste fino, siga estas etapas:

Crie um diretório para os scripts de carga de trabalho. Use esse diretório como diretório de trabalho.
```
mkdir llm-finetuning-gemma
cd llm-finetuning-gemma
```

Crie o arquivo cloudbuild.yaml para criar a imagem do contêiner de carga de trabalho com o Cloud Build e envie-o para o 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

Crie um arquivo Dockerfile para definir o ambiente e instalar as dependências necessárias para concluir o job de ajuste fino:

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

Crie o arquivo accel_fsdp_gemma4_config.yaml. Essa configuração direciona o Hugging Face Accelerate para fragmentar Gemma4TextDecoderLayer em 16 GPUs em dois hosts usando o 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

Crie o manifesto JobSet do 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

Crie o script de ajuste supervisionado 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()

Usar o Docker e o Cloud Build para criar um contêiner de ajuste fino

Criar um repositório Docker do Artifact Registry:

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

Instale as definições de recursos personalizados (CRDs) JobSet necessárias para orquestrar cargas de trabalho de vários hosts:

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

No diretório llm-finetuning-gemma criado em uma etapa anterior, envie a criação do contêiner para o Cloud Build:
```
gcloud builds submit . \
    --substitutions=_ARTIFACT_REPO_LOCATION="${ARTIFACT_REPO_LOCATION}"
```
**Observação**: a criação e o envio da imagem do contêiner CUDA e PyTorch levam aproximadamente 20 minutos para serem concluídos. Como cloudbuild.yaml define logging: CLOUD_LOGGING_ONLY, a resposta ao comando gera um link (Logs are available at [...]) que pode ser aberto no Google Cloud console para monitorar o progresso da criação em tempo real.

Exporte o URL da imagem do contêiner de vários hosts. Você o usará em uma etapa posterior deste tutorial, ao implantar o manifesto JobSet:

IMAGE_REGISTRY="${ARTIFACT_REPO_LOCATION}-docker.pkg.dev/${PROJECT_ID}"
export IMAGE_URL="${IMAGE_REGISTRY}/gemma/finetune-gemma-multihost-gpu:2.0.0"

Iniciar a carga de trabalho de ajuste fino

Para implantar e monitorar a carga de trabalho de ajuste fino distribuída, siga estas etapas:

Substitua as variáveis de ambiente no manifesto de ajuste fino para criar o job de ajuste fino:
```
envsubst '${RESERVATION} ${IMAGE_URL} ${NUM_NODES}' < finetune.yaml \
    | kubectl apply -f -
```
Como o cluster é executado no modo Autopilot do GKE, pode levar alguns minutos para provisionar os dois nós A4 ativados para GPU e extrair a imagem do contêiner.
Observe os pods de worker até que os dois pods façam a transição para o status Running:
```
watch kubectl get pods
```
Depois que os pods de worker fizerem a transição para Running, transmita os registros de treinamento:
```
kubectl logs -l "job-name=finetune-jobset-workers-0" -f
```
Observação: kubectl logs só gera registros de treinamento depois que os pods de worker entram no estado Running. Cada worker faz o download dos pesos do modelo Gemma 4 31B (isso leva aproximadamente cinco minutos) e, em seguida, executa o ajuste fino distribuído do FSDP v2 em todas as 16 GPUs. Os checkpoints são salvos a cada 15 etapas e enviados automaticamente para o repositório privado do Hugging Face Hub em https://huggingface.co/YOUR_HF_USERNAME/gemma-31b-text-to-sql.

Monitorar a carga de trabalho

É possível monitorar a utilização da GPU no cluster do GKE para verificar se todas as 16 GPUs nos dois hosts A4 estão processando ativamente as etapas de treinamento. Gere e abra o link de observabilidade no 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\"))"

Ao monitorar a carga de trabalho, espere o seguinte comportamento:

Utilização da GPU: para um job de ajuste fino distribuído normal, você pode esperar ver a utilização da GPU em todas as 16 GPUs NVIDIA B200 aumentar e estabilizar perto de 95% a 100% durante as etapas de treinamento.
Duração do job: em dois nós a4-highgpu-8g (16 GPUs B200), o job de ajuste fino de 3 épocas leva aproximadamente 2 horas e meia para ser concluído.

Conferir os pesos do adaptador ajustado

Quando o treinamento terminar, confira os pesos e checkpoints do adaptador LoRA ajustado no Hugging Face Hub em https://huggingface.co/YOUR_HF_USERNAME/gemma-31b-text-to-sql.

Limpar

Para evitar cobranças adicionais, exclua os recursos criados durante este tutorial.

Excluir os recursos

Exclua o JobSet de ajuste fino:
```
kubectl delete jobset finetune-jobset
```

Exclua seu Cluster do GKE:

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

Exclua o repositório do Artifact Registry:

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