Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

Gemma 4 in einem A4-GKE-Cluster abstimmen

Geclusterte GPUs

In dieser Anleitung wird beschrieben, wie Sie ein Gemma 4-LLM (Large Language Model) in einem GKE-Cluster (Google Kubernetes Engine) mit einem einzelnen Host und mehreren GPUs in Google Cloudfeinabstimmen. Dieser Cluster verwendet eine einzelne virtuelle A4-Maschine (VM) mit 8 angehängten NVIDIA B200-GPUs.

Die beiden Hauptprozesse, die in dieser Anleitung beschrieben werden, sind:

Einen leistungsstarken GKE-Cluster mit GKE Autopilot bereitstellen. Im Rahmen dieser Bereitstellung verwenden Sie Cloud Build, um ein benutzerdefiniertes Container-Image mit der erforderlichen vorinstallierten Software zu erstellen.
Nachdem der Cluster bereitgestellt wurde, führen Sie einen Feinabstimmungsjob aus, der Fully Sharded Data Parallel (FSDP) verwendet, um das Modell auf alle acht GPUs eines einzelnen A4-Knotens (a4-highgpu-8g) aufzuteilen. Der Job verwendet die Scripts, die zu dieser Anleitung gehören, und nutzt die Hugging Face Accelerate-Bibliothek.

Diese Anleitung richtet sich an ML-Entwickler, Forscher, Plattformadministratoren und -operatoren sowie an Daten- und KI-Spezialisten, die GKE-Cluster auf Google Cloud bereitstellen möchten, um LLMs zu trainieren.

Ziele

Greifen Sie über Hugging Face auf das Gemma 4-Modell zu.
Bereiten Sie Ihre Umgebung vor.
A4-GKE-Cluster erstellen und bereitstellen
Optimieren Sie das Gemma 4-Modell mit der Hugging Face Accelerate-Bibliothek mit vollständig fragmentierter Datenparallelität (Fully Sharded Data Parallelism, FSDP).
den Job überwachen
bereinigen.

Kosten

In diesem Dokument verwenden Sie die folgenden kostenpflichtigen Komponenten von Google Cloud:

Mit dem Preisrechner können Sie eine Kostenschätzung für Ihre voraussichtliche Nutzung vornehmen.

Neuen Nutzern von Google Cloud steht möglicherweise eine kostenlose Testversion zur Verfügung.

Hinweis

Aktivieren Sie die erforderlichen APIs, falls sie noch nicht aktiviert sind:

Rollen, die zum Aktivieren von APIs erforderlich sind
Zum Aktivieren von APIs benötigen Sie die Berechtigung serviceusage.services.enable. Wenn Sie das Projekt erstellt haben, haben Sie diese Berechtigung wahrscheinlich bereits über die Inhaberrolle (roles/owner). Andernfalls können Sie diese Berechtigung über die Rolle „Service Usage-Administrator“ (roles/serviceusage.serviceUsageAdmin) erhalten. Informationen zum Zuweisen von Rollen
```
gcloud services enable compute.googleapis.com container.googleapis.com artifactregistry.googleapis.com cloudbuild.googleapis.com logging.googleapis.com cloudresourcemanager.googleapis.com servicenetworking.googleapis.com
```

Aktivieren Sie das Standarddienstkonto für Ihr Google Cloud -Projekt:

export PROJECT_NUMBER="$(gcloud projects describe "YOUR_PROJECT_ID" --format "value(project_number)")"
gcloud iam service-accounts enable "${PROJECT_NUMBER}-compute@" \
    --project=YOUR_PROJECT_ID

Weisen Sie dem Standarddienstkonto die Rollen zu, die es zum Ausführen der Feinabstimmungsarbeitslast benötigt:

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@" \
      --role="${role}" 1>/dev/null
done
unset ROLES

Führen Sie den folgenden Befehl aus, um zu prüfen, ob die Rollen zugewiesen wurden:

gcloud projects get-iam-policy YOUR_PROJECT_ID \
    --flatten="bindings[].members" \
    --filter="bindings.members:serviceAccount:${PROJECT_NUMBER}-compute@" \
    --format="table(bindings.role)"

Erstellen Sie lokale Authentifizierungsdaten für Ihr Nutzerkonto:
```
gcloud auth application-default login
```
Hinweis: Wenn Sie eine lokale Shell und einen externen Identitätsanbieter (IdP) verwenden und nach dem Ausführen des vorherigen Befehls ein Authentifizierungsfehler auftritt, melden Sie sich mit Ihrer föderierten Identität in der gcloud CLI an.

Aktivieren Sie OS Login für Ihr Projekt:

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

Bitten Sie Ihren Administrator, Ihnen die folgenden IAM-Rollen für Ihr Projekt zuzuweisen, um die Berechtigungen zu erhalten, die Sie zum Ausführen dieser Anleitung benötigen:

Kubernetes Engine-Administrator (roles/container.admin)
Compute-Administrator (roles/compute.admin)
Storage-Administrator (roles/storage.admin)
Artifact Registry-Administrator (roles/artifactregistry.admin)
Cloud Build-Bearbeiter (roles/cloudbuild.builds.editor)
Service Account User (roles/iam.serviceAccountUser)
Dienstkontoadministrator (roles/iam.serviceAccountAdmin)
Projekt-IAM-Administrator (roles/resourcemanager.projectIamAdmin)
Service Usage-Administrator ()roles/serviceusage.serviceUsageAdmin

Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

Sie können die erforderlichen Berechtigungen auch über benutzerdefinierte Rollen oder andere vordefinierte Rollen erhalten.

Über Hugging Face auf Gemma 4 zugreifen

So greifen Sie über Hugging Face auf Gemma 4 zu:

Bei Hugging Face anmelden
Erstellen Sie ein Hugging Face-write-Zugriffstoken.
Klicken Sie auf Mein Profil > Einstellungen > Zugriffstokens > + Neues Token erstellen.
Kopieren und speichern Sie den Wert des write access-Tokens. Sie benötigen sie später in dieser Anleitung.

Umgebung vorbereiten

Legen Sie Folgendes fest, um Ihre Umgebung vorzubereiten:

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"

gcloud config set project "${PROJECT_ID}"
gcloud config set billing/quota_project "${PROJECT_ID}"

Ersetzen Sie Folgendes:

YOUR_PROJECT_ID: die ID des Google Cloud -Projekts, in dem Sie den GKE-Cluster erstellen möchten.
YOUR_CLUSTER_NAME: der Name des zu erstellenden GKE-Cluster.
YOUR_REGION: die Region, in der Sie Ihren GKE-Cluster erstellen möchten. Sie können den Cluster nur in der Region erstellen, in der sich Ihre Reservierung befindet.
YOUR_RESERVATION_NAME: die Kennung für Ihre reservierte Kapazität.
YOUR_HF_TOKEN: Das Hugging Face-Zugriffstoken, das Sie im vorherigen Abschnitt erstellt haben.
YOUR_ARTIFACT_REGISTRY_LOCATION: die Google Cloud Region, in der Sie Ihr Artifact Registry-Repository erstellen möchten. Um die Latenz beim Abrufen von Images zu minimieren, empfehlen wir, dieselbe Region zu verwenden, die Sie für YOUR_REGION verwendet haben.

GKE-Cluster im Autopilot-Modus erstellen

Führen Sie den folgenden Befehl aus, um einen GKE-Cluster im Autopilot-Modus zu erstellen:

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

Das Erstellen des GKE-Cluster kann einige Zeit dauern. Wenn Sie prüfen möchten, ob Google Cloud die Erstellung des Clusters abgeschlossen hat, rufen Sie in der Google Cloud Console die Seite Kubernetes-Cluster auf.

Kubernetes-Secret für Hugging Face-Anmeldedaten erstellen

So erstellen Sie ein Kubernetes-Secret für Hugging Face-Anmeldedaten:

Konfigurieren Sie kubectl für die Kommunikation mit Ihrem GKE-Cluster:

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

Erstellen Sie ein Kubernetes-Secret, um Ihr Hugging Face-Token zu speichern:

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

Arbeitslast vorbereiten

So bereiten Sie Ihre Arbeitslast vor:

Arbeitslastskripts erstellen
Container für die Feinabstimmung mit Docker und Cloud Build erstellen

Arbeitslastskripts erstellen

So erstellen Sie die Skripts, die von Ihrer Feinabstimmungsarbeitslast verwendet werden:

Erstellen Sie ein Verzeichnis für die Arbeitslastskripts. Verwenden Sie dieses Verzeichnis als Arbeitsverzeichnis.
```
mkdir llm-finetuning-gemma
cd llm-finetuning-gemma
```

Erstellen Sie die Datei cloudbuild.yaml, um Google Cloud Build zu verwenden. Mit dieser Datei wird der Arbeitslastcontainer erstellt und in Artifact Registry gespeichert:

steps:
- name: 'gcr.io/cloud-builders/docker'
  args:
  - 'build'
  - '-t'
  - '$_ARTIFACT_REPO_LOCATION-docker.pkg.dev/$PROJECT_ID/gemma/finetune-gemma-gpu:2.0.0'
  - '.'
images:
- '$_ARTIFACT_REPO_LOCATION-docker.pkg.dev/$PROJECT_ID/gemma/finetune-gemma-gpu:2.0.0'
options:
  logging: CLOUD_LOGGING_ONLY

Erstellen Sie eine Dockerfile-Datei, um den Job für die Feinabstimmung auszuführen:

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>=4.53.3" \
    "datasets>=4.0.0" \
    "accelerate>=1.9.0" \
    evaluate==0.4.5 \
    bitsandbytes==0.46.1 \
    "trl>=0.19.1" \
    "peft>=0.16.0" \
    tensorboard==2.20.0 \
    protobuf==6.31.1 \
    sentencepiece==0.2.0
COPY finetune.py /finetune.py
COPY accel_fsdp_gemma4_config.yaml /accel_fsdp_gemma4_config.yaml
CMD accelerate launch --config_file accel_fsdp_gemma4_config.yaml finetune.py

Erstellen Sie die Datei accel_fsdp_gemma4_config.yaml. Diese Konfigurationsdatei weist Hugging Face Accelerate an, den Abstimmungsjob mithilfe von FSDP auf die acht lokalen GPUs auf Ihrem einzelnen Host aufzuteilen:

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: false
  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: 1
num_processes: 8
rdzv_backend: static
same_network: true
tpu_env: []
tpu_use_cluster: false
tpu_use_sudo: false
use_cpu: false

Erstellen Sie die Datei finetune.yaml.

apiVersion: batch/v1
kind: Job
metadata:
  name: finetune-job
  namespace: default
spec:
  backoffLimit: 2
  template:
    metadata:
      annotations:
        kubectl.kubernetes.io/default-container: finetuner
    spec:
      terminationGracePeriodSeconds: 600
      containers:
      - name: finetuner
        image: $IMAGE_URL
        command: ["accelerate","launch"]
        args:
        - "--config_file"
        - "accel_fsdp_gemma4_config.yaml"
        - "finetune.py"
        - "--model_id"
        - "google/gemma-4-31B-it"
        - "--output_dir"
        - "gemma-31b-text-to-sql"
        - "--per_device_train_batch_size"
        - "2"
        - "--gradient_accumulation_steps"
        - "32"
        - "--num_train_epochs"
        - "3"
        - "--learning_rate"
        - "1e-5"
        - "--save_strategy"
        - "steps"
        - "--save_steps"
        - "20"
        - "--push_to_hub"
        resources:
          limits:
            nvidia.com/gpu: "8"
            memory: "1200Gi"
            ephemeral-storage: "350Gi"
          requests:
            nvidia.com/gpu: "8"
            memory: "1200Gi"
            ephemeral-storage: "350Gi"
        env:
        - name: HF_TOKEN
          valueFrom:
            secretKeyRef:
              name: hf-secret
              key: hf_api_token
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
      volumes:
      - name: dshm
        emptyDir:
          medium: Memory
          sizeLimit: 64Gi
      nodeSelector:
        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
      restartPolicy: OnFailure

Erstellen Sie die Datei finetune.py.

import torch
import argparse
import subprocess
from datasets import load_dataset
from transformers import (
    AutoTokenizer,
    AutoModelForCausalLM,
    BitsAndBytesConfig,
    AutoConfig,
)
from peft import LoraConfig
from trl import SFTTrainer, SFTConfig
from huggingface_hub import login

def get_args():
    parser = argparse.ArgumentParser()
    parser.add_argument(
        "--model_id", 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 private models")
    parser.add_argument(
        "--trust_remote", type=lambda x: str(x).lower() == "true",
        default=False,
        help="Trust remote code when loading tokenizer")
    parser.add_argument(
        "--use_fast", type=lambda x: str(x).lower() == "true",
        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(
        "--output_dir", type=str, default="gemma-31b-text-to-sql",
        help="Directory 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=2,
        help="Batch size per device during training")
    parser.add_argument(
        "--gradient_accumulation_steps", type=int, default=32,
        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=100,
        help="Save checkpoint every X steps")
    parser.add_argument(
        "--push_to_hub", action='store_true',
        help="Push model back up to HF")
    parser.add_argument(
        "--hub_private_repo", type=lambda x: str(x).lower() == "true",
        default=True,
        help="Push to a private repo")
    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
        torch_dtype_str = "bfloat16"
    else:
        torch_dtype_obj = torch.float16
        torch_dtype_str = "float16"
    tokenizer = AutoTokenizer.from_pretrained(
        args.model_id,
        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 Apply PEFT ---
    config = AutoConfig.from_pretrained(args.model_id)
    config.use_cache = False
    print("Loading base model...")
    model = AutoModelForCausalLM.from_pretrained(
        args.model_id,
        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",
        # Train only the text decoder projections; skip vision/audio modules.
        target_modules=[
            "q_proj", "k_proj", "v_proj", "o_proj",
            "gate_proj", "up_proj", "down_proj",
        ],
        exclude_modules=(
            r".*(vision_tower|audio_tower|embed_vision|embed_audio).*"),
        task_type="CAUSAL_LM",
    )
    # --- 6. Configure Training Arguments ---
    training_args = SFTConfig(
        output_dir=args.output_dir,
        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=True if torch_dtype_obj == torch.float16 else False,
        bf16=True if torch_dtype_obj == torch.bfloat16 else False,
        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.output_dir}")
    if trainer.is_fsdp_enabled:
        trainer.accelerator.state.fsdp_plugin.set_state_dict_type(
            "FULL_STATE_DICT")
    trainer.save_model(args.output_dir)
    if torch.distributed.is_initialized():
        torch.distributed.destroy_process_group()

if __name__ == "__main__":
    main()

Container für die Feinabstimmung mit Docker und Cloud Build erstellen

Artifact Registry-Docker-Repository erstellen:

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

Führen Sie im Verzeichnis llm-finetuning-gemma, das Sie in einem vorherigen Schritt erstellt haben, den folgenden Befehl aus, um das Feinabstimmungs-Image zu erstellen und per Push an Artifact Registry zu senden.
```
gcloud builds submit . \
    --substitutions=_ARTIFACT_REPO_LOCATION="${ARTIFACT_REPO_LOCATION}"
```
Hinweis: Das Erstellen und Hochladen des Images kann 20 Minuten oder länger dauern. Öffnen Sie den Link, den der Befehl mit der Ausgabe Logs are available at bereitstellt, um den Build-Fortschritt aufzurufen.

Exportieren Sie die Bild-URL. Sie benötigen sie in einem späteren Schritt dieser Anleitung:

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

Arbeitslast für die Feinabstimmung starten

So starten Sie Ihre Feinabstimmungs-Arbeitslast:

Wenden Sie das Manifest für die Feinabstimmung an, um den Job für die Feinabstimmung zu erstellen:
```
envsubst < finetune.yaml | kubectl apply -f -
```
Da Sie Cluster im GKE-Autopilot-Modus verwenden, kann es einige Minuten dauern, bis der GPU-fähige Knoten gestartet wird.
Überwachen Sie den Job mit folgendem Befehl:
```
watch kubectl get pods
```
Prüfen Sie die Logs des Jobs, nachdem die Pods ausgeführt werden:
```
kubectl logs job.batch/finetune-job -f
```
Die Jobressource lädt die Modelldaten herunter und optimiert das Modell dann auf allen acht GPUs. Der Download dauert etwa fünf Minuten. Nach Abschluss des Downloads dauert die Feinabstimmung etwa 45 Minuten. Der Job speichert alle 20 Schritte einen Prüfpunkt und überträgt den optimierten LoRA-Adapter (Low-Rank Adaptation) in ein privates Hugging Face-Repository mit dem Namen gemma-31b-text-to-sql.

Rufen Sie nach Abschluss des Jobs die URL Ihres optimierten Modells auf Hugging Face ab und öffnen Sie die URL in Ihrem Browser:

HF_USERNAME=$(curl -s -H "Authorization: Bearer ${HF_TOKEN}" \
    https://huggingface.co/api/whoami-v2 | jq -r .name)
echo "https://huggingface.co/${HF_USERNAME}/gemma-31b-text-to-sql"

Arbeitslast überwachen

Sie können die Nutzung der GPUs in Ihrem GKE-Cluster überwachen, um zu prüfen, ob Ihr Feinabstimmungsjob effizient ausgeführt wird. Öffnen Sie dazu den folgenden Link in Ihrem 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\"))"

Wenn Sie Ihre Arbeitslast überwachen, können Sie Folgendes sehen:

GPU-Nutzung: Bei einem fehlerfreien Feinabstimmungsjob steigt die Nutzung aller 8 GPUs während des Trainings und stabilisiert sich auf einem hohen Niveau.
Jobdauer: Der Job sollte auf dem angegebenen A4-Cluster etwa 45 Minuten dauern.

Bereinigen

Löschen Sie die in dieser Anleitung erstellten Ressourcen, um zusätzliche Kosten zu vermeiden.

Ressourcen löschen

Führen Sie den folgenden Befehl aus, um Ihren Feinabstimmungsjob zu löschen:
```
kubectl delete job finetune-job
```

Führen Sie den folgenden Befehl aus, um den GKE-Cluster zu löschen:

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

Führen Sie den folgenden Befehl aus, um Ihr Artifact Registry-Repository zu löschen:

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