Google utilizza la tecnologia AI per tradurre i contenuti nella tua lingua preferita. Le traduzioni generate dall'AI potrebbero contenere errori.

Ottimizza Gemma 4 su un cluster GKE A4 multi-host

GPU cluster

Questo tutorial mostra come eseguire il fine-tuning di un modello linguistico di grandi dimensioni (google/gemma-4-31b-it) Gemma 4 da 31 miliardi di parametri su un cluster Google Kubernetes Engine (GKE) Autopilot multi-host e multi-GPU su Google Cloud. Questo cluster utilizza due istanze di macchine virtuali (VM) A4 (a4-highgpu-8g) con un totale di 16 GPU NVIDIA B200.

Le tre procedure principali descritte in questo tutorial sono le seguenti:

Esegui il deployment di un cluster GKE multihost in modalità Autopilot.
Crea un'immagine container personalizzata con le dipendenze di messa a punto richieste utilizzando Cloud Build.
Orchestra un carico di lavoro di messa a punto distribuito su più host su tutte le 16 GPU utilizzando JobSet di Kubernetes e la libreria Hugging Face Accelerate con Fully Sharded Data Parallel v2 (FSDP v2), eseguendo il push dei checkpoint su Hugging Face Hub.

Questo tutorial è rivolto a machine learning (ML) engineer, ricercatori, amministratori e operatori di piattaforme e specialisti di dati e AI che eseguono il deployment di cluster GKE su Google Cloud per ottimizzare i LLM su più host.

Obiettivi

Accedi al modello Gemma 4 utilizzando Hugging Face.
Prepara l'ambiente.
Crea e implementa un cluster GKE multihost A4.
Perfeziona il modello Gemma 4 31B su 16 GPU utilizzando Kubernetes JobSet e Hugging Face Accelerate con FSDP v2.
Monitorare il job.
Visualizza i pesi dell'adattatore ottimizzato su Hugging Face Hub.
Eseguire la pulizia.

Costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il calcolatore prezzi.

I nuovi utenti di Google Cloud potrebbero avere diritto a una prova senza costi.

Prima di iniziare

Per ottenere le autorizzazioni necessarie per completare questo tutorial, chiedi all'amministratore di concederti i seguenti ruoli IAM nel progetto:

Amministratore Kubernetes Engine (roles/container.admin)
Compute Admin (roles/compute.admin)
Storage Admin (roles/storage.admin)
Amministratore Artifact Registry (roles/artifactregistry.admin)
Editor Cloud Build (roles/cloudbuild.builds.editor)
Utente Service Account (roles/iam.serviceAccountUser)
Amministratore service account (roles/iam.serviceAccountAdmin)
Project IAM Admin (roles/resourcemanager.projectIamAdmin)
Amministratore Service Usage (roles/serviceusage.serviceUsageAdmin)

Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Potresti anche riuscire a ottenere le autorizzazioni richieste tramite i ruoli personalizzati o altri ruoli predefiniti.

Abilita le API richieste, se non sono già abilitate:

Ruoli richiesti per abilitare le API
Per abilitare le API, devi disporre dell'autorizzazione serviceusage.services.enable. Se hai creato il progetto, probabilmente disponi già di questa autorizzazione tramite il ruolo Proprietario (roles/owner). In caso contrario, puoi ottenere questa autorizzazione tramite il ruolo Amministratore utilizzo servizi (roles/serviceusage.serviceUsageAdmin). Scopri come concedere i ruoli.
```
gcloud services enable compute.googleapis.com container.googleapis.com artifactregistry.googleapis.com cloudbuild.googleapis.com logging.googleapis.com cloudresourcemanager.googleapis.com servicenetworking.googleapis.com
```

Abilita il account di servizio Compute Engine predefinito per il tuo progettoGoogle 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

Concedi i ruoli IAM con privilegi minimi necessari al account di servizio Compute Engine predefinito per creare l'immagine container e eseguire il carico di lavoro di fine tuning:
```
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
```
Nota: questo passaggio concede solo i ruoli predefiniti richiesti da questo tutorial. La concessione di un ruolo di base come Editor (roles/editor) concede al account di servizio molte più autorizzazioni di quelle necessarie e i criteri della tua organizzazione potrebbero bloccare la concessione. Per saperne di più, consulta Best practice per l'utilizzo dei service account.

Verifica che i ruoli siano stati concessi al account di servizio Compute Engine predefinito:

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

Crea credenziali di autenticazione locali per il tuo account utente:
```
gcloud auth application-default login
```
Nota: se utilizzi una shell locale e un provider di identità (IdP) esterno e si verifica un errore di autenticazione dopo aver eseguito il comando precedente, allora accedi a gcloud CLI con la tua identità federata.

Attiva OS Login per il tuo progetto:

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

Accedere a Gemma 4 utilizzando Hugging Face

Per utilizzare Hugging Face per accedere a Gemma 4, completa i seguenti passaggi:

Accedi a Hugging Face e accetta il contratto di licenza di Gemma 4.
Crea un token di accesso write di Hugging Face.
Fai clic su Il tuo profilo > Impostazioni > Token di accesso > +Crea nuovo token.
Copia e salva il valore del token di accesso write. Utilizzi questo token per scaricare il modello di base e fare il push dei checkpoint dell'adattatore ottimizzato all'hub Hugging Face prima che GKE faccia lo scale down dei nodi GPU.

prepara l'ambiente

Per preparare l'ambiente, imposta le seguenti variabili di 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}"

Sostituisci quanto segue:

YOUR_PROJECT_ID: l'ID del progetto Google Cloud in cui vuoi creare il cluster GKE.
YOUR_CLUSTER_NAME: il nome del cluster GKE da creare.
YOUR_REGION: la regione in cui vuoi creare il cluster GKE. Puoi creare il cluster solo nella regione in cui esiste la prenotazione.
YOUR_RESERVATION_NAME: l'identificatore della capacità riservata.
YOUR_HF_TOKEN: il token di accesso write di Hugging Face che hai creato nella sezione precedente.
YOUR_ARTIFACT_REGISTRY_LOCATION: la Google Cloud regione (ad esempio, us-central1) in cui vuoi creare il repository Artifact Registry. Per ridurre al minimo la latenza di pull delle immagini, utilizza la stessa regione che hai specificato per YOUR_REGION.
YOUR_NUMBER_OF_NODES: il numero di nodi VM A4 nel tuo job di perfezionamento. Per questo tutorial multi-host con 16 GPU NVIDIA B200 in due istanze a4-highgpu-8g, imposta questo valore su 2.

Crea un cluster GKE multihost in modalità Autopilot

Crea un cluster GKE multihost in modalità Autopilot:

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

La creazione del cluster GKE potrebbe richiedere diversi minuti. Per verificare che Google Cloud abbia terminato la creazione del cluster, vai a Cluster Kubernetes nella console Google Cloud .

Configura kubectl per comunicare con il tuo cluster GKE

Configura kubectl per comunicare con il cluster GKE:

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

Crea un secret Kubernetes per le credenziali di Hugging Face

Crea un secret Kubernetes per archiviare il token Hugging Face:

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

Prepara il workload

Per preparare il workload:

Crea script del workload.
Utilizza Docker e Cloud Build per creare un container di perfezionamento.

Crea script del workload

Per creare i file di configurazione e gli script utilizzati dal tuo workload di fine tuning, completa i seguenti passaggi:

Crea una directory per gli script del workload. Usa questa directory come directory di lavoro.
```
mkdir llm-finetuning-gemma
cd llm-finetuning-gemma
```

Crea il file cloudbuild.yaml per creare l'immagine container del tuo workload con Cloud Build ed eseguirne il push su 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

Crea un file Dockerfile per definire l'ambiente e installare le dipendenze necessarie per completare il job di perfezionamento:

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

Crea il file accel_fsdp_gemma4_config.yaml. Questa configurazione indirizza Hugging Face Accelerate per partizionare Gemma4TextDecoderLayer su 16 GPU su due host utilizzando 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

Crea il manifest 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

Crea lo script di fine-tuning supervisionato 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()

Utilizza Docker e Cloud Build per creare un container di fine tuning

Crea un repository Docker Artifact Registry:

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

Installa le definizioni di risorse personalizzate (CRD) JobSet richieste per orchestrare i workload multihost:

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

Nella directory llm-finetuning-gemma che hai creato in un passaggio precedente, invia la build del container a Cloud Build:
```
gcloud builds submit . \
    --substitutions=_ARTIFACT_REPO_LOCATION="${ARTIFACT_REPO_LOCATION}"
```
Nota: la creazione e il push dell'immagine container CUDA e PyTorch richiedono circa 20 minuti. Poiché cloudbuild.yaml imposta logging: CLOUD_LOGGING_ONLY, il comando restituisce un link (Logs are available at [...]) che puoi aprire nella console Google Cloud per monitorare l'avanzamento della build in tempo reale.
Esporta l'URL dell'immagine container multihost. Lo utilizzerai in un passaggio successivo di questo tutorial, quando esegui il deployment del manifest JobSet:
```
IMAGE_REGISTRY="${ARTIFACT_REPO_LOCATION}-docker.pkg.dev/${PROJECT_ID}"
export IMAGE_URL="${IMAGE_REGISTRY}/gemma/finetune-gemma-multihost-gpu:2.0.0"
```

Avvia il workload di perfezionamento

Per eseguire il deployment e monitorare il carico di lavoro di fine tuning distribuito, completa i seguenti passaggi:

Sostituisci le variabili di ambiente nel manifest di fine tuning per creare il job di fine tuning:
```
envsubst '${RESERVATION} ${IMAGE_URL} ${NUM_NODES}' < finetune.yaml \
    | kubectl apply -f -
```
Poiché il cluster viene eseguito in modalità GKE Autopilot, potrebbero essere necessari alcuni minuti per eseguire il provisioning dei due nodi A4 abilitati per la GPU e estrarre l'immagine container.
Osserva i pod worker finché entrambi non passano allo stato Running:
```
watch kubectl get pods
```
Dopo che i pod worker passano a Running, trasmetti in streaming i log di addestramento:
```
kubectl logs -l "job-name=finetune-jobset-workers-0" -f
```
Nota: kubectl logs restituisce i log di addestramento solo dopo che i pod dei worker entrano nello stato Running. Ogni worker scarica i pesi del modello Gemma 4 31B (operazione che richiede circa 5 minuti) e poi esegue il fine tuning FSDP v2 distribuito su tutte le 16 GPU. I checkpoint vengono salvati ogni 15 passaggi e caricati automaticamente nel tuo repository privato di Hugging Face Hub all'indirizzo https://huggingface.co/YOUR_HF_USERNAME/gemma-31b-text-to-sql.

Monitora il workload

Puoi monitorare l'utilizzo della GPU nel cluster GKE per verificare che tutte le 16 GPU di entrambi gli host A4 stiano elaborando attivamente i passaggi di addestramento. Genera e apri il link di osservabilità nel browser:

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

Quando monitori il carico di lavoro, prevedi il seguente comportamento:

Utilizzo della GPU: per un job di messa a punto distribuita integro, puoi aspettarti di vedere l'utilizzo della GPU su tutte le 16 GPU NVIDIA B200 aumentare e stabilizzarsi tra il 95% e il 100% durante i passaggi di addestramento.
Durata del job: in due nodi a4-highgpu-8g (16 GPU B200), il job di perfezionamento di 3 epoche richiede circa 2 ore e mezza per essere completato.

Visualizzare i pesi dell'adattatore ottimizzato

Al termine dell'addestramento, visualizza i pesi dell'adattatore LoRA ottimizzato e i checkpoint su Hugging Face Hub all'indirizzo https://huggingface.co/YOUR_HF_USERNAME/gemma-31b-text-to-sql.

Esegui la pulizia

Per evitare addebiti aggiuntivi, elimina le risorse create durante questo tutorial.

Eliminare le risorse

Elimina l'ottimizzazione JobSet:
```
kubectl delete jobset finetune-jobset
```

Elimina il cluster GKE:

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

Elimina il repository Artifact Registry:

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