Offene Gemma-Modelle mit mehreren GPUs in GKE optimieren

In dieser Anleitung wird beschrieben, wie Sie das Gemma-LLM (Large Language Model), eine Familie offener Modelle, mit Grafikprozessoren (GPUs) in Google Kubernetes Engine (GKE) mit der Transformer-Bibliothek von Hugging Face optimieren. Die Feinabstimmung ist ein überwachter Lernprozess, bei dem die Fähigkeit eines vortrainierten Modells, bestimmte Aufgaben auszuführen, verbessert wird, indem seine Parameter mit einem neuen Dataset aktualisiert werden. In dieser Anleitung laden Sie die vortrainierten Modelle der Gemma-Familie mit 2B-Parametern von Hugging Face herunter und optimieren sie in einem GKE-Cluster vom Typ Autopilot oder Standard.

Dieser Leitfaden ist ein guter Ausgangspunkt, wenn Sie für die Feinabstimmung eines LLM die detaillierte Kontrolle, Skalierbarkeit, Robustheit, Übertragbarkeit und Kosteneffizienz einer verwalteten Kubernetes-Umgebung benötigen. Wenn Sie eine einheitliche verwaltete KI-Plattform benötigen, um ML-Modelle schnell und kostengünstig zu erstellen und bereitzustellen, empfehlen wir Ihnen, unsere Vertex AI-Lösung zu testen.

Hintergrund

Wenn Sie Gemma mithilfe von GPUs in GKE mit der Transformer-Bibliothek bereitstellen, können Sie eine robuste, produktionsbereite Inferenzbereitstellungslösung mit allen Vorteilen von verwaltetem Kubernetes implementieren, darunter effiziente Skalierbarkeit und höhere Verfügbarkeit. In diesem Abschnitt werden die in diesem Leitfaden verwendeten Schlüsseltechnologien beschrieben.

Gemma

Gemma ist eine Reihe offen verfügbarer, einfacher und auf künstliche Intelligenz basierender Modelle, die unter einer offenen Lizenz veröffentlicht wurden. Diese KI-Modelle können in Ihren Anwendungen, Geräten, Mobilgeräten oder gehosteten Diensten ausgeführt werden.

In diesem Leitfaden stellen wir Gemma für die Textgenerierung vor. Sie können diese Modelle auch für bestimmte Aufgaben optimieren.

In diesem Dokument verwenden Sie das Dataset b-mc2/sql-create-context.

Weitere Informationen finden Sie in der Gemma-Dokumentation.

GPUs

Mit GPUs können Sie bestimmte Arbeitslasten wie maschinelles Lernen und Datenverarbeitung beschleunigen, die auf Ihren Knoten ausgeführt werden. GKE bietet eine Reihe von Maschinentypoptionen für die Knotenkonfiguration, einschließlich Maschinentypen mit NVIDIA H100-, L4- und A100-GPUs.

Bevor Sie GPUs in GKE verwenden, sollten Sie den folgenden Lernpfad durcharbeiten:

  1. Aktuelle Verfügbarkeit von GPU-Versionen
  2. GPUs in GKE

Hugging Face-Transformer

Mit der Transformer-Bibliothek von Hugging Face können Sie auf modernste vortrainierte Modelle zugreifen. Mit der Transformers-Bibliothek können Sie den Zeit-, Ressourcen- und Rechenaufwand für das gesamte Modelltraining reduzieren.

In dieser Anleitung verwenden Sie die APIs und Tools von Hugging Face, um diese vortrainierten Modelle herunterzuladen und zu optimieren.

Ziele

Diese Anleitung richtet sich an neue oder bestehende Nutzer von GKE, ML-Entwickler, MLOps-Entwickler (DevOps) oder Plattformadministratoren, die daran interessiert sind, Funktionen zur Kubernetes-Containerorchestrierung für die Feinabstimmung von LLMs auf H100-, A100- und L4-GPU-Hardware zu nutzen.

Sie sollten am Ende dieses Leitfadens in der Lage sein, die folgenden Schritte auszuführen:

  1. Ihre Umgebung mit einem GKE-Cluster im Autopilot-Modus vorbereiten.
  2. Erstellen Sie einen Container für die Feinabstimmung.
  3. Verwenden Sie eine GPU, um das Gemma 2B-Modell zu optimieren, und laden Sie das Modell in Hugging Face hoch.

Hinweise

  • Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

  • In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  • Make sure that billing is enabled for your Google Cloud project.

  • Enable the required API.

    Enable the API

    •

  • In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  • Make sure that billing is enabled for your Google Cloud project.

  • Enable the required API.

    Enable the API

    •

  • Make sure that you have the following role or roles on the project: roles/container.admin, roles/iam.serviceAccountAdmin

    Check for the roles

    1. In the Google Cloud console, go to the IAM page.

      Go to IAM
    2. Select the project.

    3. In the Principal column, find all rows that identify you or a group that you're included in. To learn which groups you're included in, contact your administrator.

    4. For all rows that specify or include you, check the Role colunn to see whether the list of roles includes the required roles.

    Grant the roles

    1. In the Google Cloud console, go to the IAM page.

      IAM aufrufen
    2. Wählen Sie das Projekt aus.
    3. Klicken Sie auf Zugriff erlauben.

    4. Geben Sie im Feld Neue Hauptkonten Ihre Nutzer-ID ein. Dies ist in der Regel die E-Mail-Adresse eines Google-Kontos.

    5. Wählen Sie in der Liste Rolle auswählen eine Rolle aus.
    6. Wenn Sie weitere Rollen hinzufügen möchten, klicken Sie auf Weitere Rolle hinzufügen und fügen Sie weitere Rollen hinzu.
    7. Klicken Sie auf Speichern.
  • Erstellen Sie ein Hugging Face-Konto, falls Sie noch keines haben.
  • Prüfen Sie, ob Ihr Projekt ein ausreichendes Kontingent für GPUs hat. Weitere Informationen finden Sie unter GPUs und Zuteilungskontingente.

Zugriff auf das Modell erhalten

Wenn Sie Zugriff auf die Gemma-Modelle für die Bereitstellung in GKE erhalten möchten, müssen Sie zuerst die Lizenzeinwilligungsvereinbarung unterzeichnen und dann ein Hugging-Face-Zugriffstoken generieren.

Sie müssen die Einwilligungsvereinbarung unterzeichnen, um Gemma verwenden zu können. Gehen Sie dazu so vor:

  1. Rufen Sie die Seite zur Modelleinwilligung auf Kaggle.com auf.
  2. Bestätigen Sie die Einwilligung mit Ihrem Hugging Face-Konto.
  3. Akzeptieren Sie die Modellbedingungen.

Zugriffstoken erstellen

Für den Zugriff auf das Modell über Hugging Face benötigen Sie ein Hugging Face-Token.

Führen Sie die folgenden Schritte aus, um ein neues Token zu generieren, falls Sie noch keines haben:

  1. Klicken Sie auf Profil > Einstellungen > Zugriffstokens.
  2. Wählen Sie Neues Token aus.
  3. Geben Sie einen Namen Ihrer Wahl und eine Rolle von mindestens Write an.
  4. Wählen Sie Token generieren aus.
  5. Kopieren Sie das Token in die Zwischenablage.

Umgebung vorbereiten

In dieser Anleitung verwenden Sie Cloud Shell zum Verwalten von Ressourcen, die in Google Cloud gehostet werden. Die Software, die Sie für diese Anleitung benötigen, ist in Cloud Shell vorinstalliert, einschließlich kubectl und gcloud CLI.

So richten Sie Ihre Umgebung mit Cloud Shell ein:

  1. Starten Sie in der Google Cloud Console eine Cloud Shell-Sitzung. Klicken Sie dazu in der Google Cloud Console auf Symbol für die Cloud Shell-Aktivierung Cloud Shell aktivieren. Dadurch wird im unteren Bereich der Google Cloud Console eine Sitzung gestartet.

  2. Legen Sie die Standardumgebungsvariablen fest:

    gcloud config set project PROJECT_ID
export PROJECT_ID=$(gcloud config get project)
export REGION=REGION
export CLUSTER_NAME=finetuning
export HF_TOKEN=HF_TOKEN
export HF_PROFILE=HF_PROFILE

    Ersetzen Sie die folgenden Werte:

    • PROJECT_ID: Ihre Google Cloud-Projekt-ID.
    • REGION ist eine Region, die den Beschleunigertyp unterstützt, den Sie verwenden möchten, z. B. us-central1 für L4-GPU.
    • HF_TOKEN ist das Hugging Face-Token, das Sie zuvor generiert haben.
    • HF_PROFILE: Die Hugging Face-Profil-ID, die Sie zuvor erstellt haben.

  3. Klonen Sie das Beispielcode-Repository aus GitHub:

    git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples
cd kubernetes-engine-samples/ai-ml/llm-finetuning-gemma

Google Cloud-Ressourcen erstellen und konfigurieren

Folgen Sie dieser Anleitung, um die erforderlichen Ressourcen zu erstellen.

GKE-Cluster und -Knotenpool erstellen

Sie können Gemma auf GPUs in einem GKE-Cluster im Autopilot- oder Standardmodus bereitstellen. Für eine vollständig verwaltete Kubernetes-Umgebung empfehlen wir die Verwendung eines Autopilot-Clusters. Informationen zum Auswählen des GKE-Betriebsmodus, der für Ihre Arbeitslasten am besten geeignet ist, finden Sie unter GKE-Betriebsmodus auswählen.

Autopilot

Führen Sie in Cloud Shell den folgenden Befehl aus:

gcloud container clusters create-auto ${CLUSTER_NAME} \
  --project=${PROJECT_ID} \
  --region=${REGION} \
  --release-channel=rapid \
  --cluster-version=1.29

GKE erstellt einen Autopilot-Cluster mit CPU- und GPU-Knoten, wie von den bereitgestellten Arbeitslasten angefordert.

Standard

  1. Führen Sie in Cloud Shell den folgenden Befehl aus, um einen Standardcluster zu erstellen:

    gcloud container clusters create ${CLUSTER_NAME} \
  --project=${PROJECT_ID} \
  --region=${REGION} \
  --workload-pool=${PROJECT_ID}.svc.id.goog \
  --release-channel=rapid \
  --num-nodes=1

    Die Erstellung eines Clusters kann einige Minuten dauern.

  2. Führen Sie den folgenden Befehl aus, um einen Knotenpool für Ihren Cluster zu erstellen:

    gcloud container node-pools create gpupool \
  --accelerator type=nvidia-l4,count=8,gpu-driver-version=latest \
  --project=${PROJECT_ID} \
  --location=${REGION} \
  --node-locations=${REGION}-a \
  --cluster=${CLUSTER_NAME} \
  --machine-type=g2-standard-96 \
  --num-nodes=1

    GKE erstellt einen einzelnen Knotenpool mit zwei L4-GPUs für jeden Knoten.

Kubernetes-Secret für Hugging Face-Anmeldedaten erstellen

Gehen Sie in Cloud Shell so vor:

  1. Konfigurieren Sie kubectl für die Kommunikation mit Ihrem Cluster:

    gcloud container clusters get-credentials ${CLUSTER_NAME} --location=${REGION}

  2. Erstellen Sie ein Kubernetes-Secret, das das Hugging Face-Token enthält:

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

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

In diesem Container wird der PyTorch- und Hugging Face-Transformer-Code verwendet, um das vorhandene vortrainierte Gemma-Modell zu optimieren.

  1. Artifact Registry-Docker-Repository erstellen

    gcloud artifacts repositories create gemma \
    --project=${PROJECT_ID} \
    --repository-format=docker \
    --location=us \
    --description="Gemma Repo"

  2. Erstellen Sie das Image und übertragen Sie es per Push:

    gcloud builds submit .

  3. Exportieren Sie IMAGE_URL für die spätere Verwendung in dieser Anleitung.

    export IMAGE_URL=us-docker.pkg.dev/$PROJECT_ID/gemma/finetune-gemma-gpu:1.0.0

Job zur Feinabstimmung in GKE ausführen

Gemma-Job für die Feinabstimmung bereitstellen

  1. Öffnen 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
        resources:
          limits:
            nvidia.com/gpu: "8"
        env:
        - name: MODEL_NAME
          value: "google/gemma-2b"
        - name: NEW_MODEL
          value: "gemma-2b-sql-finetuned"
        - name: LORA_R
          value: "8"
        - name: LORA_ALPHA
          value: "16"
        - name: TRAIN_BATCH_SIZE
          value: "1"
        - name: EVAL_BATCH_SIZE
          value: "2"
        - name: GRADIENT_ACCUMULATION_STEPS
          value: "2"
        - name: DATASET_LIMIT
          value: "1000"
        - name: MAX_SEQ_LENGTH
          value: "512"
        - name: LOGGING_STEPS
          value: "5"
        - name: HF_TOKEN
          valueFrom:
            secretKeyRef:
              name: hf-secret
              key: hf_api_token
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
      volumes:
      - name: dshm
        emptyDir:
          medium: Memory
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-l4
      restartPolicy: OnFailure

  2. Wenden Sie das Manifest an, um den Job für die Feinabstimmung zu erstellen:

    envsubst < finetune.yaml | kubectl apply -f -

    Mit dieser Anweisung wird die IMAGE_URL durch die Variable im Manifest ersetzt.

  3. Überwachen Sie den Job mit folgendem Befehl:

    watch kubectl get pods

  4. Prüfen Sie die Logs des Jobs mit dem folgenden Befehl:

    kubectl logs job.batch/finetune-job -f

    Die Jobressource lädt die Modelldaten herunter und optimiert das Modell dann auf allen acht GPUs. Das kann bis zu 20 Minuten dauern.

  5. Rufen Sie nach Abschluss des Jobs Ihr Hugging Face-Konto auf. In Ihrem Hugging Face-Profil wird ein neues Modell mit dem Namen $HF_PROFILE/gemma-2b-sql-finetuned angezeigt.

Optimiertes Modell in GKE bereitstellen

In diesem Abschnitt stellen Sie den vLLM-Container für das Gemma-Modell bereit.

  1. Erstellen Sie das folgende serve-gemma.yaml-Manifest:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: vllm-gemma-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: gemma-server
  template:
    metadata:
      labels:
        app: gemma-server
        ai.gke.io/model: gemma-2b
        ai.gke.io/inference-server: vllm
        examples.ai.gke.io/source: user-guide
    spec:
      containers:
      - name: inference-server
        image: us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20240220_0936_RC01
        resources:
          requests:
            cpu: "2"
            memory: "7Gi"
            ephemeral-storage: "10Gi"
            nvidia.com/gpu: 1
          limits:
            cpu: "2"
            memory: "7Gi"
            ephemeral-storage: "10Gi"
            nvidia.com/gpu: 1
        command: ["python3", "-m", "vllm.entrypoints.api_server"]
        args:
        - --model=$(MODEL_ID)
        - --tensor-parallel-size=1
        env:
        - name: MODEL_ID
          value: google/gemma-2b
        - name: HUGGING_FACE_HUB_TOKEN
          valueFrom:
            secretKeyRef:
              name: hf-secret
              key: hf_api_token
        volumeMounts:
        - mountPath: /dev/shm
          name: dshm
      volumes:
      - name: dshm
        emptyDir:
            medium: Memory
      nodeSelector:
        cloud.google.com/gke-accelerator: nvidia-l4
---
apiVersion: v1
kind: Service
metadata:
  name: llm-service
spec:
  selector:
    app: gemma-server
  type: ClusterIP
  ports:
    - protocol: TCP
      port: 8000
      targetPort: 8000

  2. Umgebungsvariable für neue MODEL_ID erstellen 

    export MODEL_ID=$HF_PROFILE/gemma-2b-sql-finetuned

  3. Ersetzen Sie MODEL_ID im Manifest:

    sed -i "s|google/gemma-2b|$MODEL_ID|g" serve-gemma.yaml

  4. Wenden Sie das Manifest an:

    kubectl apply -f serve-gemma.yaml

    Ein Pod im Cluster lädt die Modellgewichtungen von Hugging Face herunter und startet die Bereitstellungs-Engine.

  5. Warten Sie, bis die Bereitstellung verfügbar ist:

    kubectl wait --for=condition=Available --timeout=700s deployment/vllm-gemma-deployment

  6. So rufen Sie die Logs des laufenden Deployments auf:

    kubectl logs -f -l app=gemma-server

Die Deployment-Ressource lädt die Modelldaten herunter. Das kann einige Minuten dauern. Die Ausgabe sieht in etwa so aus:

INFO 01-26 19:02:54 model_runner.py:689] Graph capturing finished in 4 secs.
INFO:     Started server process [1]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C to quit)

Das Modell muss vollständig heruntergeladen sein, bevor Sie mit dem nächsten Abschnitt fortfahren.

Modell bereitstellen

In diesem Abschnitt interagieren Sie mit dem Modell.

Portweiterleitung einrichten

Führen Sie nach der Bereitstellung des Modells den folgenden Befehl aus, um die Portweiterleitung zum Modell einzurichten:

kubectl port-forward service/llm-service 8000:8000

Die Ausgabe sieht in etwa so aus:

Forwarding from 127.0.0.1:8000 -> 8000

Mithilfe von curl mit dem Modell interagieren

Verwenden Sie in einer neuen Terminalsitzung curl, um mit Ihrem Modell zu chatten:

Der folgende Beispielbefehl ist für TGI

USER_PROMPT="Question: What is the total number of attendees with age over 30 at kubecon eu? Context: CREATE TABLE attendees (name VARCHAR, age INTEGER, kubecon VARCHAR)"

curl -X POST http://localhost:8000/generate \
  -H "Content-Type: application/json" \
  -d @- <<EOF
{
    "prompt": "${USER_PROMPT}",
    "temperature": 0.1,
    "top_p": 1.0,
    "max_tokens": 24
}
EOF

Die folgende Ausgabe zeigt ein Beispiel für die Modellantwort:

{"generated_text":" Answer: SELECT COUNT(age) FROM attendees WHERE age > 30 AND kubecon = 'eu'\n"}

Je nach Abfrage müssen Sie möglicherweise die max_token ändern, um ein besseres Ergebnis zu erhalten. Sie können auch das Modell mit Instruction Tuning verwenden, um die Chatqualität zu verbessern.

Bereinigen

Damit Ihrem Google Cloud-Konto die in dieser Anleitung verwendeten Ressourcen nicht in Rechnung gestellt werden, löschen Sie entweder das Projekt, das die Ressourcen enthält, oder Sie behalten das Projekt und löschen die einzelnen Ressourcen.

Bereitgestellte Ressourcen löschen

Mit dem folgenden Befehl vermeiden Sie, dass Ihrem Google Cloud-Konto die in dieser Anleitung erstellten Ressourcen in Rechnung gestellt werden:

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

Nächste Schritte