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

Neste tutorial, você vai aprender a ajustar um modelo de linguagem grande (google/gemma-4-31b-it) Gemma 4 de 31 bilhões de parâmetros em um cluster do Autopilot do Google Kubernetes Engine (GKE) com vários hosts e GPUs no 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 processos principais descritos neste tutorial são:

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 refinado 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 Hugging Face Accelerate com o paralelismo de dados totalmente fragmentados 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 no Google Cloud para ajustar LLMs em vários hosts.

Objetivos

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

Custos

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

Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, 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 necessárias a fim de concluir o tutorial, peça ao administrador para conceder a você os seguintes papéis do IAM no 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 de projetos do IAM (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 usando papéis personalizados ou outros papéis predefinidos.

Ative as APIs necessárias, se alguma ainda não estiver ativada:

Funções necessárias para ativar APIs
Para ativar APIs, você precisa da permissão serviceusage.services.enable. Se você criou o projeto, provavelmente já tem essa permissão pelo papel de Proprietário (roles/owner). Caso contrário, é possível receber essa permissão pelo papel de 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 projetoGoogle Cloud :

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 com privilégio mínimo 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 refinado:
```
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 as 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 encontrar 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 no 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 e 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. Use esse token para fazer o download do modelo de base e enviar checkpoints de adaptadores ajustados para o Hugging Face Hub antes que o GKE reduza os nós de 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.
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 está.
YOUR_RESERVATION_NAME: o identificador da capacidade reservada.
YOUR_HF_TOKEN: o token de acesso write do Hugging Face 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 especificada para YOUR_REGION.
YOUR_NUMBER_OF_NODES: o número de nós de VM A4 no seu job de ajuste refinado. 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 terminou de criar o cluster, acesse Clusters do Kubernetes no console Google Cloud .

Configure 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 seu 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:

Criar 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 sua carga de trabalho de ajuste refinado, siga estas etapas:

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

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

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 do finetune.yaml Kubernetes JobSet:

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

Crie 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) do 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
```
No diretório llm-finetuning-gemma criado em uma etapa anterior, envie a build 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 do CUDA e do PyTorch levam aproximadamente 20 minutos. Como o cloudbuild.yaml define logging: CLOUD_LOGGING_ONLY, a resposta ao comando gera um link (Logs are available at [...]) que pode ser aberto no console do Google Cloud para monitorar o progresso da build em tempo real.

Exporte o URL da imagem de contêiner de vários hosts. Você vai usá-lo 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 refinado

Para implantar e monitorar sua carga de trabalho de ajuste refinado distribuído, siga estas etapas:

Substitua as variáveis de ambiente no manifesto de ajuste para criar o job de ajuste:
```
envsubst '${RESERVATION} ${IMAGE_URL} ${NUM_NODES}' < finetune.yaml \
    | kubectl apply -f -
```
Como o cluster é executado no modo GKE Autopilot, pode levar alguns minutos para provisionar os dois nós A4 habilitados para GPU e extrair a imagem do contêiner.
Aguarde até que os dois pods de worker 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: o kubectl logs só gera registros de treinamento depois que os pods de trabalho entram no estado Running. Cada worker faz o download dos pesos do modelo Gemma 4 31B (isso leva aproximadamente cinco minutos) e 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 seu repositório privado do Hugging Face Hub em https://huggingface.co/YOUR_HF_USERNAME/gemma-31b-text-to-sql.

Monitore sua 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 sua carga de trabalho, espere o seguinte comportamento:

Utilização da GPU: para um job de ajuste refinado distribuído saudável, é esperado que a utilização da GPU em todas as 16 GPUs NVIDIA B200 aumente e se estabilize 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 refinado de 3 épocas leva aproximadamente 2 horas e meia para ser concluído.

Ver os pesos do adaptador refinado

Quando o treinamento terminar, confira os pesos e os pontos de verificação 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 extras, exclua os recursos criados durante este tutorial.

Excluir os recursos

Exclua o ajuste JobSet:
```
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