Gemma mithilfe von TPUs in GKE mit JetStream bereitstellen

In dieser Anleitung wird beschrieben, wie Sie ein Gemma-LLM (Large Language Model) mit Tensor Processing Units (TPUs) in Google Kubernetes Engine (GKE) bereitstellen. Sie stellen einen vorgefertigten Container mit JetStream und MaxText in GKE bereit. Sie konfigurieren GKE auch so, dass die Gemma 7B-Gewichtungen zur Laufzeit aus Cloud Storage geladen werden.

Diese Anleitung richtet sich an ML-Entwickler (Machine Learning), Plattformadministratoren und ‑operatoren sowie an Daten- und KI-Spezialisten, die daran interessiert sind, Kubernetes-Container-Orchestrierungsfunktionen zum Bereitstellen von LLMs zu nutzen. Weitere Informationen zu gängigen Rollen und Beispielaufgaben, auf die wir inGoogle Cloud -Inhalten verweisen, finden Sie unter Häufig verwendete GKE-Nutzerrollen und -Aufgaben.

Machen Sie sich vor dem Lesen dieser Seite mit den folgenden Themen vertraut:

• Autopilot-Modus und Standardmodus
• Aktuelle Verfügbarkeit von TPU-Versionen unter Cloud TPU-Systemarchitektur
• TPUs in GKE

Hintergrund

In diesem Abschnitt werden die in dieser Anleitung 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. Sie können die Gemma-Modelle zur Textgenerierung verwenden. Sie können diese Modelle jedoch auch für spezielle Aufgaben optimieren.

Weitere Informationen finden Sie in der Gemma-Dokumentation.

TPUs

TPUs sind von Google speziell entwickelte anwendungsspezifische integrierte Schaltungen (Application-Specific Integrated Circuits, ASICs), die verwendet werden, um das maschinelle Lernen und die KI-Modelle zu beschleunigen, die mit Frameworks wie folgenden erstellt wurden:TensorFlow, PyTorch und JAX.

In dieser Anleitung wird das Bereitstellen des Modells Gemma 7B beschrieben. GKE stellt das Modell auf TPUv5e-Knoten mit einem einzelnen Host bereit. Dabei werden TPU-Topologien basierend auf den Modellanforderungen für die Bereitstellung von Eingabeaufforderungen mit niedriger Latenz konfiguriert.

JetStream

JetStream ist ein von Google entwickeltes Open-Source-Framework zur Bereitstellung von Inferenzen. JetStream ermöglicht leistungsstarke, durchsatzintensive und speicheroptimierte Inferenz auf TPUs und GPUs. Es bietet erweiterte Leistungsoptimierungen, einschließlich Techniken zur kontinuierlichen Batch- und Quantisierung, um die LLM-Bereitstellung zu erleichtern. JetStream ermöglicht die PyTorch/XLA- und JAX-TPU-Bereitstellung, um eine optimale Leistung zu erzielen.

Weitere Informationen zu diesen Optimierungen finden Sie in den Projekt-Repositories JetStream PyTorch und JetStream MaxText.

MaxText

MaxText ist eine leistungsstarke, skalierbare und anpassbare JAX LLM-Implementierung, die auf Open-Source-JAX-Bibliotheken auf folgende Weise basiert: Flax, Orbax undOptax. Die nur Decoder-LLM-Implementierung von MaxText ist in Python geschrieben. Es nutzt den XLA-Compiler stark aus, um eine hohe Leistung zu erzielen, ohne benutzerdefinierte Kernel erstellen zu müssen.

Weitere Informationen zu den neuesten Modellen und Parametergrößen, die von MaxText unterstützt werden, finden Sie im Projekt-Repository MaxtText.

Lernziele

1. Bereiten Sie einen GKE Autopilot- oder Standardcluster mit der empfohlenen TPU-Topologie anhand der Modelleigenschaften vor.
2. JetStream-Komponenten in GKE bereitstellen
3. Anleitung zum optimierten Gemma 7B-Modell abrufen und veröffentlichen.
4. Stellen Sie das veröffentlichte Modell bereit und interagieren Sie damit.

Architektur

In diesem Abschnitt wird die in dieser Anleitung verwendete GKE-Architektur beschrieben. Die Architektur umfasst einen GKE Autopilot- oder Standardcluster, der TPUs bereitstellt und JetStream-Komponenten zum Bereitstellen und Bereitstellen der Modelle hostet.

Das folgende Diagramm zeigt die Komponenten dieser Architektur:

Diese Architektur umfasst die folgenden Komponenten:

• Regionaler GKE-Autopilot- oder Standard-Cluster.
• Zwei TPU-Slice-Knotenpools mit einem Host, die die JetStream-Bereitstellung hosten.
• Die Dienstkomponente verteilt eingehenden Traffic auf alle JetStream HTTP-Replikate.
• JetStream HTTP ist ein HTTP-Server, der Anfragen als Wrapper für das erforderliche Format von JetStream akzeptiert und an den GRPC-Client von JetStream sendet.
• Maxengine ist ein JetStream-Server, der Inferenzen mit kontinuierlicher Batchverarbeitung ausführt.

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

Verify 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

Verify 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, roles/resourcemanager.projectIamAdmin

  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 column 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.

     Zu IAM
  2. Wählen Sie das Projekt aus.
  3. Klicken Sie auf person_add 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 add Weitere Rolle hinzufügen und fügen Sie weitere Rollen hinzu.
  7. Klicken Sie auf Speichern.
  • Prüfen Sie, ob Sie ein ausreichendes Kontingent für acht TPU v5e PodSlice Lite-Chips haben. In dieser Anleitung verwenden Sie On-Demand-Instanzen.
  • Erstellen Sie ein Kaggle-Konto, falls Sie noch keines haben.

  Zugriff auf das Modell erhalten

  Für den Zugriff auf das Gemma-Modell für die Bereitstellung in GKE müssen Sie zuerst die Lizenzeinwilligungsvereinbarung unterzeichnen.

  Lizenz-Einwilligungsvereinbarung unterzeichnen

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

  1. Rufen Sie die Seite zur Einwilligung des Gemma-Modells auf Kaggle.com auf.
  2. Melden Sie sich bei Kaggle an, falls Sie dies noch nicht getan haben.
  3. Klicken Sie auf Zugriffsanfrage.
  4. Wählen Sie im Abschnitt Konto zur Einwilligung die Option Über Kaggle-Konto verifizieren aus, um Ihr Kaggle-Konto für die Einwilligung zu verwenden.
  5. Akzeptieren Sie die Nutzungsbedingungen des Modells.

  Zugriffstoken erstellen

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

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

  1. Rufen Sie in Ihrem Browser die Kaggle-Einstellungen auf.
  2. Klicken Sie im Abschnitt API auf Neues Token erstellen.

  Eine Datei mit dem Namen kaggle.json wird heruntergeladen.

  Umgebung vorbereiten

  In dieser Anleitung verwenden Sie Cloud Shell zum Verwalten von Ressourcen, die inGoogle Cloudgehostet 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 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
     gcloud config set billing/quota_project PROJECT_ID
     export PROJECT_ID=$(gcloud config get project)
     export CLUSTER_NAME=CLUSTER_NAME
     export BUCKET_NAME=BUCKET_NAME
     export REGION=REGION
     export LOCATION=LOCATION
     export CLUSTER_VERSION=CLUSTER_VERSION
     

     Ersetzen Sie die folgenden Werte:

     • PROJECT_ID: Ihre Google Cloud Projekt-ID.
     • CLUSTER_NAME: der Name Ihres GKE-Clusters.
     • BUCKET_NAME: Der Name Ihres Cloud Storage-Buckets. Sie müssen das Präfix gs:// nicht angeben.
     • REGION: Die Region, in der sich der GKE-Cluster, der Cloud Storage-Bucket und die TPU-Knoten befinden. Die Region enthält Zonen, in denen TPU v5e-Maschinentypen verfügbar sind, z. B. us-west1, us-west4, us-central1, us-east1, us-east5 oder europe-west4. Achten Sie bei Autopilot-Clustern darauf, dass Sie für die ausgewählte Region genügend zonale TPU v5e-Ressourcen haben.
     • (Nur Standardcluster) LOCATION: Die Zone, in der die TPU-Ressourcen verfügbar sind (z. B. us-west4-a). Bei Autopilot-Clustern müssen Sie nicht die Zone angeben, sondern nur die Region.
     • CLUSTER_VERSION: Die GKE-Version, die den gewünschten Maschinentyp unterstützen muss. Die GKE-Standardversion ist für Ihre Ziel-TPU möglicherweise nicht verfügbar. Eine Liste der für TPU-Maschinentypen verfügbaren GKE-Mindestversionen finden Sie unter TPU-Verfügbarkeit in GKE.

  Google Cloud -Ressourcen erstellen und konfigurieren

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

  GKE-Cluster erstellen

  Sie können Gemma auf GPUs in einem TPUs-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} \
    --cluster-version=${CLUSTER_VERSION}
  

  Standard

  1. Einen regionalen GKE Standard-Cluster erstellen, der Workload Identity-Föderation für GKE verwendet.

     gcloud container clusters create ${CLUSTER_NAME} \
         --enable-ip-alias \
         --machine-type=e2-standard-4 \
         --num-nodes=2 \
         --cluster-version=${CLUSTER_VERSION} \
         --workload-pool=${PROJECT_ID}.svc.id.goog \
         --location=${REGION}
     

     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 gemma-7b-tpu-nodepool \
       --cluster=${CLUSTER_NAME} \
       --machine-type=ct5lp-hightpu-8t \
       --project=${PROJECT_ID} \
       --num-nodes=2 \
       --region=${REGION} \
       --node-locations=${LOCATION}
     

     GKE erstellt einen TPU v5e-Knotenpool mit einer 2x4-Topologie und zwei Knoten.

  Cloud Storage-Bucket erstellen

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

  gcloud storage buckets create gs://${BUCKET_NAME} --location=${REGION}
  

  Dadurch wird ein Cloud Storage-Bucket zum Speichern der Modelldateien erstellt, die Sie von Kaggle herunterladen.

  Zugriffstoken in Cloud Shell hochladen

  In Cloud Shell können Sie das Kaggle API-Token in Ihr Google Cloud-Projekt hochladen:

  1. Klicken Sie in Cloud Shell auf more_vert Mehr > Hochladen.
  2. Wählen Sie "Datei" aus und klicken Sie auf Dateien auswählen.
  3. Öffnen Sie die Datei kaggle.json.
  4. Klicken Sie auf Hochladen.

  Kubernetes-Secret für Kaggle-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 Secret zum Speichern der Kaggle-Anmeldedaten:

     kubectl create secret generic kaggle-secret \
         --from-file=kaggle.json
     

  Arbeitslastzugriff mit Identitätsföderation von Arbeitslasten für GKE konfigurieren

  Weisen Sie der Anwendung ein Kubernetes-ServiceAccount zu und konfigurieren Sie dieses Kubernetes-Dienstkonto als IAM-Dienstkonto.

  1. Erstellen Sie ein IAM-Dienstkonto für Ihre Anwendung:

     gcloud iam service-accounts create wi-jetstream
     

  2. Fügen Sie eine IAM-Richtlinienbindung für Ihr IAM-Dienstkonto hinzu, um Cloud Storage zu verwalten:

     gcloud projects add-iam-policy-binding ${PROJECT_ID} \
         --member "serviceAccount:wi-jetstream@${PROJECT_ID}.iam.gserviceaccount.com" \
         --role roles/storage.objectUser
     
     gcloud projects add-iam-policy-binding ${PROJECT_ID} \
         --member "serviceAccount:wi-jetstream@${PROJECT_ID}.iam.gserviceaccount.com" \
         --role roles/storage.insightsCollectorService
     

  3. Erlauben Sie dem Kubernetes-ServiceAccount, die Identität des IAM-Dienstkontos zu übernehmen. Fügen Sie dazu eine IAM-Richtlinienbindung zwischen den beiden Dienstkonten hinzu. Durch diese Bindung kann das Kubernetes-Dienstkonto als IAM-Dienstkonto verwendet werden.

     gcloud iam service-accounts add-iam-policy-binding wi-jetstream@${PROJECT_ID}.iam.gserviceaccount.com \
         --role roles/iam.workloadIdentityUser \
         --member "serviceAccount:${PROJECT_ID}.svc.id.goog[default/default]"
     

  4. Kennzeichnen Sie das Kubernetes-Dienstkonto mit der E-Mail-Adresse des IAM-Dienstkontos:

     kubectl annotate serviceaccount default \
         iam.gke.io/gcp-service-account=wi-jetstream@${PROJECT_ID}.iam.gserviceaccount.com
     

  Modellprüfpunkte konvertieren

  In diesem Abschnitt erstellen Sie einen Job für Folgendes:

  1. Laden Sie den Basis-Orbax-Prüfpunkt von Kaggle herunter.
  2. Laden Sie den Prüfpunkt in einen Cloud Storage-Bucket hoch.
  3. Wandeln Sie den Prüfpunkt in einen MaxText-kompatiblen Prüfpunkt um.
  4. Heben Sie den Scan des Prüfpunkts auf, der für die Bereitstellung verwendet werden soll.

  Modellprüfpunkt-Konvertierungsjob bereitstellen

  Folgen Sie dieser Anleitung, um die Prüfpunktdateien des Gemma 7B-Modells herunterzuladen und zu konvertieren. In dieser Anleitung wird ein Kubernetes-Job verwendet. Ein Jobcontroller in Kubernetes erstellt einen oder mehrere Pods und sorgt dafür, dass sie eine bestimmte Aufgabe erfolgreich ausführen.

  1. Erstellen Sie das folgende Manifest als job-7b.yaml:

     apiVersion: batch/v1
     kind: Job
     metadata:
       name: data-loader-7b
     spec:
       ttlSecondsAfterFinished: 30
       template:
         spec:
           restartPolicy: Never
           containers:
           - name: inference-checkpoint
             image: us-docker.pkg.dev/cloud-tpu-images/inference/inference-checkpoint:v0.2.4
             args:
             - -b=BUCKET_NAME
             - -m=google/gemma/maxtext/7b-it/2
             volumeMounts:
             - mountPath: "/kaggle/"
               name: kaggle-credentials
               readOnly: true
             resources:
               requests:
                 google.com/tpu: 8
               limits:
                 google.com/tpu: 8
           nodeSelector:
             cloud.google.com/gke-tpu-topology: 2x4
             cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
           volumes:
           - name: kaggle-credentials
             secret:
               defaultMode: 0400
               secretName: kaggle-secret
     

  2. Wenden Sie das Manifest an:

     kubectl apply -f job-7b.yaml
     

  3. Warten Sie, bis der Pod, der den Job plant, ausgeführt wird:

     kubectl get pod -w
     

     Die Ausgabe sollte in etwa so aussehen (dies kann einige Minuten dauern):

     NAME                  READY   STATUS              RESTARTS   AGE
     data-loader-7b-abcd   0/1     ContainerCreating   0          28s
     data-loader-7b-abcd   1/1     Running             0          51s
     

     Bei Autopilot-Clustern kann es einige Minuten dauern, bis die erforderlichen TPU-Ressourcen bereitgestellt werden.

  4. So rufen Sie die Logs des Jobs auf:

     kubectl logs -f jobs/data-loader-7b
     

     Wenn der Job abgeschlossen ist, sieht die Ausgabe in etwa so aus:

     Successfully generated decode checkpoint at: gs://BUCKET_NAME/final/unscanned/gemma_7b-it/0/checkpoints/0/items
     + echo -e '\nCompleted unscanning checkpoint to gs://BUCKET_NAME/final/unscanned/gemma_7b-it/0/checkpoints/0/items'
     
     Completed unscanning checkpoint to gs://BUCKET_NAME/final/unscanned/gemma_7b-it/0/checkpoints/0/items
     

  JetStream bereitstellen

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

  Folgen Sie dieser Anleitung, um das für die Anleitung abgestimmte Modell Gemma 7B bereitzustellen. In dieser Anleitung wird eine Kubernetes-Bereitstellung verwendet. Ein Deployment ist ein Kubernetes-API-Objekt, mit dem Sie mehrere Replikate von Pods ausführen können, die auf die Knoten in einem Cluster verteilt sind.

  1. Speichern Sie das folgende Deployment-Manifest als jetstream-gemma-deployment.yaml:

     apiVersion: apps/v1
     kind: Deployment
     metadata:
       name: maxengine-server
     spec:
       replicas: 1
       selector:
         matchLabels:
           app: maxengine-server
       template:
         metadata:
           labels:
             app: maxengine-server
         spec:
           nodeSelector:
             cloud.google.com/gke-tpu-topology: 2x4
             cloud.google.com/gke-tpu-accelerator: tpu-v5-lite-podslice
           containers:
           - name: maxengine-server
             image: us-docker.pkg.dev/cloud-tpu-images/inference/maxengine-server:v0.2.2
             args:
             - model_name=gemma-7b
             - tokenizer_path=assets/tokenizer.gemma
             - per_device_batch_size=4
             - max_prefill_predict_length=1024
             - max_target_length=2048
             - async_checkpointing=false
             - ici_fsdp_parallelism=1
             - ici_autoregressive_parallelism=-1
             - ici_tensor_parallelism=1
             - scan_layers=false
             - weight_dtype=bfloat16
             - load_parameters_path=gs://BUCKET_NAME/final/unscanned/gemma_7b-it/0/checkpoints/0/items
             - prometheus_port=PROMETHEUS_PORT
             ports:
             - containerPort: 9000
             resources:
               requests:
                 google.com/tpu: 8
               limits:
                 google.com/tpu: 8
           - name: jetstream-http
             image: us-docker.pkg.dev/cloud-tpu-images/inference/jetstream-http:v0.2.2
             ports:
             - containerPort: 8000
     ---
     apiVersion: v1
     kind: Service
     metadata:
       name: jetstream-svc
     spec:
       selector:
         app: maxengine-server
       ports:
       - protocol: TCP
         name: jetstream-http
         port: 8000
         targetPort: 8000
       - protocol: TCP
         name: jetstream-grpc
         port: 9000
         targetPort: 9000
     

     Das Manifest legt die folgenden wichtigen Attribute fest:

     • tokenizer_path ist der Pfad zum Tokenizer Ihres Modells.
     • load_parameters_path: der Pfad im Cloud Storage-Bucket, in dem Ihre Prüfpunkte gespeichert sind.
     • per_device_batch_size: die Batchgröße für Decodierung pro Gerät, wobei ein TPU-Chip einem Gerät entspricht.
     • max_prefill_predict_length: die maximale Länge für das Vorausfüllen bei der automatischen Regression.
     • max_target_length: die maximale Sequenzlänge.
     • model_name ist der Modellname (gemma-7b).
     • ici_fsdp_parallelism: die Anzahl der Shards für die vollständig fragmentierte Datenparallelität (FSDP).
     • ici_tensor_parallelism: die Anzahl der Shards für die Tensor-Parallelität.
     • ici_autoregressive_parallelism: die Anzahl der Shards für die autoregressive Parallelität.
     • prometheus_port: Port, über den Prometheus-Messwerte verfügbar gemacht werden. Entfernen Sie dieses Argument, wenn keine Messwerte benötigt werden.
     • scan_layers: boolesches Flag „Scan Layers“.
     • weight_dtype: der Datentyp für die Gewichtung (bfloat16).

  2. Wenden Sie das Manifest an:

     kubectl apply -f jetstream-gemma-deployment.yaml
     

  3. Bereitstellung prüfen:

     kubectl get deployment
     

     Die Ausgabe sieht in etwa so aus:

     NAME                              READY   UP-TO-DATE   AVAILABLE   AGE
     maxengine-server                  2/2     2            2           ##s
     

     Bei Autopilot-Clustern kann es einige Minuten dauern, bis die erforderlichen TPU-Ressourcen bereitgestellt werden.

  4. Prüfen Sie anhand der HTTP-Server-Logs, ob das Modell geladen und kompiliert wurde. Es kann einige Minuten dauern, bis der Server diesen Vorgang abgeschlossen hat.

     kubectl logs deploy/maxengine-server -f -c jetstream-http
     

     Die Ausgabe sieht in etwa so aus:

     kubectl logs deploy/maxengine-server -f -c jetstream-http
     
     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)
     

  5. Rufen Sie die MaxEngine-Logs auf und prüfen Sie, ob die Kompilierung abgeschlossen ist:

     kubectl logs deploy/maxengine-server -f -c maxengine-server
     

     Die Ausgabe sieht in etwa so aus:

     2024-03-29 17:09:08,047 - jax._src.dispatch - DEBUG - Finished XLA compilation of jit(initialize) in 0.26236414909362793 sec
     2024-03-29 17:09:08,150 - root - INFO - ---------Generate params 0 loaded.---------
     

  Modell bereitstellen

  In diesem Abschnitt interagieren Sie mit dem Modell.

  Portweiterleitung einrichten

  Sie können auf das JetStream-Deployment über den ClusterIP-Dienst zugreifen, den Sie im vorherigen Schritt erstellt haben. Die ClusterIP-Dienste sind nur innerhalb des Clusters erreichbar. Führen Sie daher die folgenden Schritte aus, um von außerhalb des Clusters auf den Dienst zuzugreifen:

  Führen Sie den folgenden Befehl aus, um eine Portweiterleitungssitzung einzurichten:

  kubectl port-forward svc/jetstream-svc 8000:8000
  

  Mithilfe von curl mit dem Modell interagieren

  1. Prüfen Sie, ob Sie auf den JetStream-HTTP-Server zugreifen können. Öffnen Sie dazu ein neues Terminal und führen Sie den folgenden Befehl aus:

     curl --request POST \
     --header "Content-type: application/json" \
     -s \
     localhost:8000/generate \
     --data \
     '{
         "prompt": "What are the top 5 programming languages",
         "max_tokens": 200
     }'
     

     Die erste Anfrage kann aufgrund der Aufwärmphase des Modells einige Sekunden dauern. Die Ausgabe sieht in etwa so aus:

     {
         "response": "\nfor data science in 2023?\n\n**1. Python:**\n- Widely used for data science due to its simplicity, readability, and extensive libraries for data wrangling, analysis, visualization, and machine learning.\n- Popular libraries include pandas, scikit-learn, and matplotlib.\n\n**2. R:**\n- Statistical programming language widely used for data analysis, visualization, and modeling.\n- Popular libraries include ggplot2, dplyr, and caret.\n\n**3. Java:**\n- Enterprise-grade language with strong performance and scalability.\n- Popular libraries include Spark, TensorFlow, and Weka.\n\n**4. C++:**\n- High-performance language often used for data analytics and machine learning models.\n- Popular libraries include TensorFlow, PyTorch, and OpenCV.\n\n**5. SQL:**\n- Relational database language essential for data wrangling and querying large datasets.\n- Popular tools"
     }
     

  Optional: Über eine Gradio-Chat-Oberfläche mit dem Modell interagieren

  In diesem Abschnitt erstellen Sie eine Webchat-Anwendung, mit der Sie mit Ihrem abgestimmten Modell für Anweisungen interagieren können.

  Gradio ist eine Python-Bibliothek mit einem ChatInterface-Wrapper, der Benutzeroberflächen für Chatbots erstellt.

  Chatoberfläche bereitstellen

  1. Speichern Sie in Cloud Shell das folgende Manifest als gradio.yaml:

     apiVersion: apps/v1
     kind: Deployment
     metadata:
       name: gradio
       labels:
         app: gradio
     spec:
       replicas: 1
       selector:
         matchLabels:
           app: gradio
       template:
         metadata:
           labels:
             app: gradio
         spec:
           containers:
           - name: gradio
             image: us-docker.pkg.dev/google-samples/containers/gke/gradio-app:v1.0.3
             resources:
               requests:
                 cpu: "512m"
                 memory: "512Mi"
               limits:
                 cpu: "1"
                 memory: "512Mi"
             env:
             - name: CONTEXT_PATH
               value: "/generate"
             - name: HOST
               value: "http://jetstream-svc:8000"
             - name: LLM_ENGINE
               value: "max"
             - name: MODEL_ID
               value: "gemma"
             - name: USER_PROMPT
               value: "<start_of_turn>user\nprompt<end_of_turn>\n"
             - name: SYSTEM_PROMPT
               value: "<start_of_turn>model\nprompt<end_of_turn>\n"
             ports:
             - containerPort: 7860
     ---
     apiVersion: v1
     kind: Service
     metadata:
       name: gradio
     spec:
       selector:
         app: gradio
       ports:
         - protocol: TCP
           port: 8080
           targetPort: 7860
       type: ClusterIP
     

  2. Wenden Sie das Manifest an:

     kubectl apply -f gradio.yaml
     

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

     kubectl wait --for=condition=Available --timeout=300s deployment/gradio
     

  Chatoberfläche verwenden

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

     kubectl port-forward service/gradio 8080:8080
     

     Dadurch wird eine Portweiterleitung von Cloud Shell zum Gradio-Dienst erstellt.

  2. Klicken Sie oben rechts in der Cloud Shell-Taskleiste auf die Schaltfläche Webvorschau. Klicken Sie auf Vorschau auf Port 8080. Im Browser wird ein neuer Tab geöffnet.

  3. Interagieren Sie über die Gradio-Chat-Oberfläche mit Gemma. Fügen Sie einen Prompt hinzu und klicken Sie auf Senden.

  Probleme beheben

  • Wenn Sie die Empty reply from server-Meldung erhalten, hat der Container möglicherweise die Modelldaten noch nicht ganz heruntergeladen. Prüfen Sie die Logs des Pods noch einmal auf die Connected-Meldung, die angibt, dass das Modell einsatzbereit ist.
  • Wenn Connection refused angezeigt wird, prüfen Sie, ob die Portweiterleitung aktiv ist.

  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

  Führen Sie die folgenden Befehle aus und folgen Sie den Eingabeaufforderungen, um zu vermeiden, dass Ihrem Google Cloud Konto die in dieser Anleitung erstellten Ressourcen in Rechnung gestellt werden:

  gcloud container clusters delete ${CLUSTER_NAME} --region=${REGION}
  
  gcloud iam service-accounts delete wi-jetstream@PROJECT_ID.iam.gserviceaccount.com
  
  gcloud storage rm --recursive gs://BUCKET_NAME
  

  Nächste Schritte

  • Erfahren Sie, wie Sie Gemma-Modelle in GKE ausführen und wie Sie optimierte KI-/ML-Arbeitslasten mit GKE-Plattformorchestrierungsfunktionen ausführen.
  • Mehr über TPUs in GKE erfahren
  • GitHub-Repository von JetStream ansehen
  • Erfahren Sie mehr über den Vertex AI Model Garden.