Google 會運用 AI 技術將內容翻譯成你偏好的語言，但可能會出錯。

在多主機 A4 GKE 叢集上微調 Gemma 4

叢集式 GPU

本教學課程會說明如何在 Google Cloud的多主機、多 GPU Google Kubernetes Engine (GKE) Autopilot 叢集上，微調 Gemma 4 31B 大型語言模型 (google/gemma-4-31b-it)。這個叢集使用兩個 A4 (a4-highgpu-8g) 虛擬機器 (VM) 執行個體，總共配備 16 個 NVIDIA B200 GPU。

本教學課程主要說明下列三種程序：

在 Autopilot 模式中部署多主機 GKE 叢集。
使用 Cloud Build 建構自訂容器映像檔，其中包含微調作業所需的依附元件。
使用 Kubernetes JobSet 和 Hugging Face Accelerate 程式庫，透過 Fully Sharded Data Parallel v2 (FSDP v2) 在所有 16 個 GPU 上調度管理分散式多主機微調工作負載，並將檢查點推送至 Hugging Face Hub。

本教學課程適用於機器學習 (ML) 工程師、研究人員、平台管理員和營運人員，以及在 Google Cloud 上部署 GKE 叢集，以跨多個主機微調 LLM 的資料和 AI 專家。

目標

使用 Hugging Face 存取 Gemma 4 模型。
準備環境。
建立及部署多主機 A4 GKE 叢集。
使用 Kubernetes JobSet 和 Hugging Face Accelerate，透過 FSDP v2 在 16 個 GPU 上微調 Gemma 4 31B 模型。
監控工作。
在 Hugging Face Hub 上查看微調的轉接器權重。
清除所用資源。

費用

在本文件中，您將使用下列 Google Cloud計費元件：

如要根據預測用量估算費用，請使用 Pricing Calculator。

初次使用 Google Cloud 的使用者可能符合免費試用期資格。

事前準備

如要取得完成本教學課程所需的權限，請要求管理員在專案中授予您下列 IAM 角色：

Kubernetes Engine 管理員 (roles/container.admin)
Compute 管理員 (roles/compute.admin)
儲存空間管理員 (roles/storage.admin)
Artifact Registry 管理員 (roles/artifactregistry.admin)
Cloud Build 編輯者 (roles/cloudbuild.builds.editor)
服務帳戶使用者 (roles/iam.serviceAccountUser)
服務帳戶管理員 (roles/iam.serviceAccountAdmin)
專案 IAM 管理員 (roles/resourcemanager.projectIamAdmin)
服務使用情形管理員 (roles/serviceusage.serviceUsageAdmin)

如要進一步瞭解如何授予角色，請參閱「管理專案、資料夾和組織的存取權」。

您或許也能透過自訂角色或其他預先定義的角色，取得必要權限。

如果尚未啟用必要的 API，請啟用：

啟用 API 時所需的角色
如要啟用 API，您必須具備 serviceusage.services.enable 權限。如果您建立了專案，可能已透過「擁有者」角色 (roles/owner) 取得這項權限。否則，您可以透過「服務使用管理員」角色 (roles/serviceusage.serviceUsageAdmin) 取得這項權限。瞭解如何授予角色。
```
gcloud services enable compute.googleapis.com container.googleapis.com artifactregistry.googleapis.com cloudbuild.googleapis.com logging.googleapis.com cloudresourcemanager.googleapis.com servicenetworking.googleapis.com
```

為您的Google Cloud 專案啟用預設的 Compute Engine 服務帳戶：

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

授予預設 Compute Engine 服務帳戶所需的最小權限 IAM 角色，以便建構容器映像檔及執行微調工作負載：

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

確認角色已授予預設的 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)"

為使用者帳戶建立本機驗證憑證：
```
gcloud auth application-default login
```
注意： 如果您使用本機殼層和外部識別資訊提供者 (IdP)，且在執行上述指令後發生驗證錯誤，請使用聯合身分登入 gcloud CLI。

為專案啟用 OS 登入功能：

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

使用 Hugging Face 存取 Gemma 4

如要使用 Hugging Face 存取 Gemma 4，請完成下列步驟：

登入 Hugging Face，然後接受 Gemma 4 授權協議。
建立 Hugging Face write 存取權杖。
依序點按「你的個人資料」>「設定」>「存取權杖」>「+ 建立新權杖」。
複製並儲存 write 存取權杖值。您可以使用這個權杖下載基礎模型，並在 GKE 縮減 GPU 節點前，將微調的轉接程式檢查點推送至 Hugging Face Hub。

準備環境

如要準備環境，請設定下列環境變數：

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

更改下列內容：

YOUR_PROJECT_ID：您要在 Google Cloud 專案中建立 GKE 叢集，請輸入該專案的 ID。
YOUR_CLUSTER_NAME：要建立的 GKE 叢集名稱。
YOUR_REGION：要建立 GKE 叢集的區域。您只能在預留項目所在的區域建立叢集。
YOUR_RESERVATION_NAME：預留容量的 ID。
YOUR_HF_TOKEN：您在前一節中建立的 Hugging Face write 存取權杖。
YOUR_ARTIFACT_REGISTRY_LOCATION：要建立 Artifact Registry 存放區的 Google Cloud 區域 (例如 us-central1)。如要盡量縮短映像檔提取延遲時間，請使用您為 YOUR_REGION 指定的相同區域。
YOUR_NUMBER_OF_NODES：微調作業中的 A4 VM 節點數量。在本多主機教學課程中，兩個 a4-highgpu-8g 執行個體共用 16 個 NVIDIA B200 GPU，因此請將這個值設為 2。

在 Autopilot 模式中建立多主機 GKE 叢集

在 Autopilot 模式中建立多主機 GKE 叢集：

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

建立 GKE 叢集可能需要幾分鐘的時間。如要確認 Google Cloud 已完成叢集建立作業，請前往 Google Cloud 控制台的「Kubernetes clusters」(Kubernetes 叢集)。

設定 kubectl 與 GKE 叢集通訊

設定 kubectl，與 GKE 叢集通訊：

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

為 Hugging Face 憑證建立 Kubernetes Secret

建立 Kubernetes Secret 來儲存 Hugging Face 權杖：

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

準備工作負載

如要準備工作負載，請執行下列操作：

建立工作負載指令碼。
使用 Docker 和 Cloud Build 建立微調容器。

建立工作負載指令碼

如要建立微調工作負載使用的設定檔和指令碼，請完成下列步驟：

為工作負載指令碼建立目錄。將這個目錄當做目前使用的目錄。
```
mkdir llm-finetuning-gemma
cd llm-finetuning-gemma
```

建立 cloudbuild.yaml 檔案，使用 Cloud Build 建構工作負載容器映像檔，並將其推送至 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

建立 Dockerfile 檔案來定義環境，並安裝完成微調作業所需的依附元件：

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

建立 accel_fsdp_gemma4_config.yaml 檔案。這項設定會指示 Hugging Face Accelerate 使用 FSDP v2，在兩部主機的 16 個 GPU 中分片 Gemma4TextDecoderLayer：

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

建立 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

建立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()

使用 Docker 和 Cloud Build 建立微調容器

建立 Artifact Registry Docker 存放區：

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

安裝編排多主機工作負載所需的JobSet自訂資源定義 (CRD)：

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

在您先前步驟中建立的 llm-finetuning-gemma 目錄中，將容器建構作業提交至 Cloud Build：
```
gcloud builds submit . \
    --substitutions=_ARTIFACT_REPO_LOCATION="${ARTIFACT_REPO_LOCATION}"
```
注意： 建構及推送 CUDA 和 PyTorch 容器映像檔大約需要 20 分鐘。由於 cloudbuild.yaml 會設定 logging: CLOUD_LOGGING_ONLY，因此指令會輸出連結 (Logs are available at [...])，您可以在 Google Cloud 控制台中開啟該連結，監控即時建構進度。

匯出多主機容器映像檔網址。在本教學課程的後續步驟中，您將部署 JobSet 資訊清單時使用：

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

啟動微調工作負載

如要部署及監控分散式微調工作負載，請完成下列步驟：

將環境變數代入微調資訊清單，建立微調工作：
```
envsubst '${RESERVATION} ${IMAGE_URL} ${NUM_NODES}' < finetune.yaml \
    | kubectl apply -f -
```
由於叢集是在 GKE Autopilot 模式下執行，因此佈建兩個啟用 GPU 的 A4 節點，以及提取容器映像檔可能需要幾分鐘的時間。
觀察 worker Pod，直到兩個 Pod 都轉換為 Running 狀態：
```
watch kubectl get pods
```
工作站 Pod 轉換為 Running 後，請串流訓練記錄：
```
kubectl logs -l "job-name=finetune-jobset-workers-0" -f
```
注意： 只有在工作站 Pod 進入 Running 狀態後，kubectl logs 才會輸出訓練記錄。每個 worker 都會下載 Gemma 4 31B 模型權重 (約需五分鐘)，然後在所有 16 個 GPU 上執行分散式 FSDP v2 微調。系統每 15 個步驟會儲存一個檢查點，並自動上傳至您在 https://huggingface.co/YOUR_HF_USERNAME/gemma-31b-text-to-sql 的私人 Hugging Face Hub 存放區。

監控工作負載

您可以監控 GKE 叢集的 GPU 使用率，確認兩個 A4 主機的所有 16 個 GPU 都正在積極處理訓練步驟。產生並在瀏覽器中開啟可觀測性連結：

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\"))"

監控工作負載時，請注意下列行為：

GPU 使用率：對於運作正常的分散式微調工作，您應該會看到所有 16 個 NVIDIA B200 GPU 的使用率在訓練步驟中上升，並穩定維持在 95% 至 100% 左右。
工作時間：在兩個 a4-highgpu-8g 節點 (16 個 B200 GPU) 上，3 個訓練週期的微調工作大約需要 2.5 小時才能完成。

查看微調的轉接程式權重

訓練完成後，您可以在 Hugging Face Hub (https://huggingface.co/YOUR_HF_USERNAME/gemma-31b-text-to-sql) 上查看微調的 LoRA 轉接器權重和檢查點。

清除所用資源

為避免產生額外費用，請刪除在本教學課程中建立的資源。

刪除資源

刪除微調作業 JobSet：
```
kubectl delete jobset finetune-jobset
```

刪除您的 GKE 叢集：

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

刪除 Artifact Registry 存放區：

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