Google은 AI 기술을 사용하여 콘텐츠를 사용자의 기본 언어로 번역합니다. AI 번역에는 오류가 있을 수 있습니다.

멀티 호스트 A4 GKE 클러스터에서 Gemma 4 파인 튜닝

클러스터링된 GPU

이 튜토리얼에서는 Google Cloud에서 멀티 호스트, 멀티 GPU Google Kubernetes Engine (GKE) Autopilot 클러스터에서 Gemma 4 31B 대규모 언어 모델 (google/gemma-4-31b-it)을 파인 튜닝하는 방법을 보여줍니다. 이 클러스터는 총 16개의 NVIDIA B200 GPU가 있는 두 개의 A4 (a4-highgpu-8g) 가상 머신 (VM) 인스턴스를 사용합니다.

이 튜토리얼에 설명된 세 가지 주요 프로세스는 다음과 같습니다.

Autopilot 모드로 다중 호스트 GKE 클러스터를 배포합니다.
Cloud Build를 사용하여 필요한 미세 조정 종속 항목이 포함된 맞춤 컨테이너 이미지를 빌드합니다.
Kubernetes JobSet과 Hugging Face Accelerate 라이브러리를 Fully Sharded Data Parallel v2 (FSDP v2)와 함께 사용하여 모든 16개의 GPU에서 분산된 다중 호스트 미세 조정 워크로드를 오케스트레이션하고 체크포인트를 Hugging Face Hub에 푸시합니다.

이 튜토리얼은 여러 호스트에서 LLM을 미세 조정하기 위해 Google Cloud 에 GKE 클러스터를 배포하는 머신러닝 (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)
서비스 사용량 관리자(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
```
참고: 이 단계에서는 이 튜토리얼에 필요한 사전 정의된 역할만 부여합니다. 편집자 (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 로그인을 사용 설정합니다.

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: 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)입니다. 이미지 가져오기 지연 시간을 최소화하려면 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 클러스터로 이동합니다.

GKE 클러스터와 통신하도록 kubectl 구성

GKE 클러스터와 통신하도록 kubectl을 구성합니다.

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

Hugging Face 사용자 인증 정보용 Kubernetes 보안 비밀 만들기

Hugging Face 토큰을 저장할 Kubernetes 보안 비밀을 만듭니다.

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
```

Cloud Build로 워크로드 컨테이너 이미지를 빌드하고 Artifact Registry에 푸시하는 cloudbuild.yaml 파일을 만듭니다.

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를 사용하여 두 호스트의 GPU 16개에 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를 설정하므로 명령어 출력은 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 모드로 실행되므로 GPU 지원 A4 노드 2개를 프로비저닝하고 컨테이너 이미지를 가져오는 데 몇 분 정도 걸릴 수 있습니다.
두 포드가 모두 Running 상태로 전환될 때까지 작업자 포드를 감시합니다.
```
watch kubectl get pods
```
작업자 포드가 Running로 전환된 후 학습 로그를 스트리밍합니다.
```
kubectl logs -l "job-name=finetune-jobset-workers-0" -f
```
참고: kubectl logs는 작업자 포드가 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시간 30분이 걸립니다.

미세 조정된 어댑터 가중치 보기

학습이 완료되면 https://huggingface.co/YOUR_HF_USERNAME/gemma-31b-text-to-sql에서 Hugging Face Hub의 파인 튜닝된 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