Gemma mithilfe von TPUs in GKE mit JetStream bereitstellen

In diesem Leitfaden erfahren Sie, wie Sie ein Gemma-Large Language Model (LLM) mit Tensor Processing Units (TPUs) in Google Kubernetes Engine (GKE) mit JetStream über MaxText bereitstellen. In dieser Anleitung laden Sie die Gemma 7B-Parameteranweisungen für die abgestimmten Modellgewichtungen in Cloud Storage herunter und stellen sie auf einem GKE-Autopilot oder -Standard mit einem Container, der JetStream ausführt, bereit. Wenn Sie beim Bereitstellen Ihres Modells in JetStream die Skalierbarkeit, Robustheit und Kosteneffizienz der Kubernetes-Features benötigen, ist dieser Leitfaden ein guter Ausgangspunkt.

Hintergrund

Durch die Bereitstellung von Gemma über TPUs in GKE mit JetStream können Sie eine robuste, produktionsreife Bereitstellungslösung mit allen Vorteilen von verwaltetem Kubernetes erstellen, einschließlich Kosteneffizienz, Skalierbarkeit und höhere Verfügbarkeit. 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.

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

  1. Lernen Sie mehr über die aktuelle Verfügbarkeit von TPU-Versionen unter Cloud TPU-Systemarchitektur.
  2. TPUs in GKE

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

Diese Anleitung richtet sich an Kunden von generativer KI, die JAX verwenden, neue oder bestehende Nutzer von GKE, ML-Entwicklern, MLOps-Entwicklern (DevOps) oder Plattformadministratoren, die daran interessiert sind, Kubernetes-Container-Orchestrierungsfunktionen zu nutzen, um LLMs bereitzustellen.

Diese Anleitung umfasst die folgenden Schritte:

  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:

Architektur des GKE-Clusters mit TPU-Knotenpools mit einzelnen Hosts, die die Maxengine- und Max-HTTP-Komponenten enthalten.

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

  • Melden Sie sich bei Ihrem Google Cloud-Konto an. Wenn Sie mit Google Cloud noch nicht vertraut sind, erstellen Sie ein Konto, um die Leistungsfähigkeit unserer Produkte in der Praxis sehen und bewerten zu können. Neukunden erhalten außerdem ein Guthaben von 300 $, um Arbeitslasten auszuführen, zu testen und bereitzustellen.

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

    Go to project selector

  • Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

  • Aktivieren Sie die erforderliche API.

    Aktivieren Sie die API

    •

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

    Go to project selector

  • Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

  • Aktivieren Sie die erforderliche API.

    Aktivieren Sie die API

    •

  • Prüfen Sie, ob Sie die folgenden Rollen für das Projekt haben: roles/container.admin, roles/iam.serviceAccountAdmin

    Auf Rollen prüfen

    1. Öffnen Sie in der Google Cloud Console die Seite IAM.

      IAM aufrufen
    2. Wählen Sie das Projekt aus.

    3. Suchen Sie in der Spalte Hauptkonto die Zeile mit Ihrer E-Mail-Adresse.

      Ist Ihre E-Mail-Adresse nicht in dieser Spalte enthalten, haben Sie keine Rollen.

    4. Prüfen Sie in der Spalte Rolle der Zeile mit Ihrer E-Mail-Adresse, ob die Liste der Rollen die erforderlichen Rollen enthält.

    Rollen zuweisen

    1. Öffnen Sie in der Google Cloud Console die Seite IAM.

      IAM aufrufen
    2. Wählen Sie das Projekt aus.
    3. Klicken Sie auf Zugriff erlauben.
    4. Geben Sie in das Feld Neue Hauptkonten Ihre E-Mail-Adresse ein.
    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.
  • 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.

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 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 CLUSTER_NAME=CLUSTER_NAME
export BUCKET_NAME=BUCKET_NAME
export REGION=REGION
export LOCATION=LOCATION

    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_NAME: 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.
    • (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.

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} \
  --release-channel=rapid \
  --cluster-version=1.29

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

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 \
    --release-channel=rapid \
    --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 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.

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

  1. Erstellen Sie das folgende jetstream-gemma-deployment.yaml-Manifest:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: maxengine-server
spec:
  replicas: 2
  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.0
        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
        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.0
        ports:
        - containerPort: 8000
---
apiVersion: v1
kind: Service
metadata:
  name: jetstream-http-svc
spec:
  selector:
    app: maxengine-server
  ports:
  - protocol: TCP
    port: 8000
    targetPort: 8000

    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.
    • scan_layers: Scan Layers boolesches Flag (boolesch).
    • 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

  4. Prüfen Sie anhand der HTTP-Serverlogs, 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-http-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-http-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 Symbol für Webvorschau 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