Google は AI 技術を使用して、コンテンツをご希望の言語に翻訳しています。AI 翻訳には誤りが含まれる場合があります。

マルチホスト A4 GKE クラスタで Gemma 4 をファインチューニングする

このチュートリアルでは、 Google Cloud上のマルチホスト、マルチ GPU Google Kubernetes Engine（GKE）Autopilot クラスタで Gemma 4 31B 大規模言語モデル（google/gemma-4-31b-it）をファインチューニングする方法について説明します。このクラスタは、合計 16 個の NVIDIA B200 GPU を搭載した 2 つの A4（a4-highgpu-8g）仮想マシン（VM）インスタンスを使用します。

このチュートリアルで説明する主なプロセスは次の 3 つです。

Autopilot モードでマルチホスト GKE クラスタをデプロイします。
Cloud Build を使用して、必要なファインチューニングの依存関係を含むカスタムコンテナイメージをビルドします。
Kubernetes JobSet と Hugging Face Accelerate ライブラリ（Fully Sharded Data Parallel v2（FSDP v2）を使用）を使用して、16 個の GPU すべてで分散マルチホストファインチューニングワークロードをオーケストレートし、チェックポイントを Hugging Face Hub に push します。

このチュートリアルは、 Google Cloud に GKE クラスタをデプロイして複数のホストで LLM をファインチューニングする機械学習（ML）エンジニア、研究者、プラットフォーム管理者、オペレーター、データおよび AI スペシャリストを対象としています。

目標

Hugging Face を使用して Gemma 4 モデルにアクセスします。
環境を準備します。
マルチホスト A4 GKE クラスタを作成してデプロイします。
Kubernetes JobSet と Hugging Face Accelerate（FSDP v2）を使用して、16 個の GPU で Gemma 4 31B モデルをファインチューニングする。
ジョブをモニタリングします。
ファインチューニングされたアダプタの重みを Hugging Face Hub で確認します。
クリーンアップする。

費用

このドキュメントでは、課金対象である次の Google Cloudコンポーネントを使用します。

料金計算ツールを使うと、予想使用量に基づいて費用の見積もりを生成できます。

新規の 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）
Service Usage 管理者（roles/serviceusage.serviceUsageAdmin）

ロールの付与については、プロジェクト、フォルダ、組織へのアクセス権の管理をご覧ください。

必要な権限は、カスタムロールや他の事前定義ロールから取得することもできます。

必要な API がまだ有効になっていない場合は、有効にします。

API を有効にするために必要なロール
API を有効にするには、serviceusage.services.enable 権限が必要です。プロジェクトを作成した場合は、オーナーロール（roles/owner）を通じてこの権限がすでに付与されている可能性があります。それ以外の場合は、Service Usage 管理者ロール（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
```
注: この手順では、このチュートリアルで必要な事前定義ロールのみが付与されます。編集者（roles/editor）などの基本ロールを付与すると、サービスアカウントに必要以上の権限が付与され、組織のポリシーによって付与がブロックされる可能性があります。詳細については、サービスアカウントの使用に関するベストプラクティスをご覧ください。

ロールがデフォルトの 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
```
注: ローカルシェルと外部 ID プロバイダ（IdP）を使用しているときに、上記のコマンドを実行した後に認証エラーが発生した場合は、フェデレーション ID を使用して gcloud CLI にログインします。

プロジェクトで OS Login を有効にします。

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 アクセストークンを作成します。
[Your Profile] > [Settings] > [Access tokens] > [+Create new token] の順にクリックします。
write アクセストークンの値をコピーして保存します。このトークンを使用して、GKE が GPU ノードをスケールダウンする前に、ベースモデルをダウンロードし、ファインチューニングされたアダプタチェックポイントを Hugging Face Hub に push します。

環境を準備する

環境を準備するには、次の環境変数を設定します。

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: GKE クラスタを作成する Google Cloud プロジェクトの ID。
YOUR_CLUSTER_NAME: 作成する GKE クラスタの名前。
YOUR_REGION: GKE クラスタを作成するリージョン。クラスタは、予約が存在するリージョンでのみ作成できます。
YOUR_RESERVATION_NAME: 予約済み容量の識別子。
YOUR_HF_TOKEN: 前のセクションで作成した Hugging Face write アクセストークン。
YOUR_ARTIFACT_REGISTRY_LOCATION: Artifact Registry リポジトリを作成する Google Cloud リージョン（例: us-central1）。イメージの pull レイテンシを最小限に抑えるには、YOUR_REGION で指定したのと同じリージョンを使用します。
YOUR_NUMBER_OF_NODES: ファインチューニングジョブの A4 VM ノードの数。このマルチホストチュートリアルでは、2 つの 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 クラスタ] に移動します。

GKE クラスタと通信するように kubectl を構成する

GKE クラスタと通信するように kubectl を構成します。

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

Hugging Face の認証情報用の Kubernetes Secret を作成する

Hugging Face トークンを保存する Kubernetes Secret を作成します。

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 に push します。

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 ファイルを作成します。この構成では、FSDP v2 を使用して、2 台のホストの 16 個の GPU に Gemma4TextDecoderLayer をシャーディングするように Hugging Face Accelerate に指示します。

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 コンテナイメージのビルドと push には、約 20 分かかります。cloudbuild.yaml は logging: CLOUD_LOGGING_ONLY を設定するため、コマンド出力は、 Google Cloud コンソールで開いてリアルタイムのビルドの進行状況を監視できるリンク（Logs are available at [...]）を出力します。
マルチホストコンテナイメージの URL をエクスポートします。この値は、このチュートリアルの後半で 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 モードで実行されるため、2 つの GPU 対応 A4 ノードのプロビジョニングとコンテナイメージの pull に数分かかることがあります。
両方の Pod が Running ステータスに移行するまで、ワーカー Pod を監視します。
```
watch kubectl get pods
```
ワーカー Pod が Running に移行したら、トレーニングログをストリーミングします。
```
kubectl logs -l "job-name=finetune-jobset-workers-0" -f
```
注: kubectl logs は、ワーカー Pod が Running 状態になった後にのみトレーニングログを出力します。各ワーカーは Gemma 4 31B モデルの重みをダウンロードし（約 5 分かかります）、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 すべてで GPU 使用率が上昇し、95 ～ 100% 近くで安定することが予想されます。
ジョブの所要時間: 2 つの a4-highgpu-8g ノード（16 個の B200 GPU）で、3 エポックのファインチューニングジョブが完了するまでに約 2 時間半かかります。

ファインチューニングされたアダプタの重みを表示する

トレーニングが完了したら、ファインチューニングされた LoRA アダプタの重みとチェックポイントを Hugging Face Hub（https://huggingface.co/YOUR_HF_USERNAME/gemma-31b-text-to-sql）で確認します。

クリーンアップ

追加料金が発生しないようにするには、このチュートリアルで作成したリソースを削除します。

リソースを削除する

ファインチューニング 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