Offene Gemma-Modelle mit GPUs in GKE mit Hugging Face TGI bereitstellen

Autopilot Standard

---

In dieser Anleitung wird beschrieben, wie Sie das Gemma-LLM (Large Language Model), eine Familie offener Modelle, mit grafischen Verarbeitungseinheiten (GPUs) in Google Kubernetes Engine (GKE) mit dem Bereitstellungs-Framework Text Generation Inference (TGI) von Hugging Face bereitstellen.

In dieser Anleitung laden Sie ein für die Anleitung abgestimmtes Modell Gemma 2 (2B-, 9B- und 27B-Parameter) oder ein CodeGemma-Modell von Hugging Face herunter. Anschließend stellen Sie das Modell in einem GKE-Cluster vom Typ Autopilot oder Standard mit einem Container bereit, in dem TGI ausgeführt wird.

Dieser Leitfaden ist ein guter Ausgangspunkt, wenn Sie bei der Bereitstellung und Zugänglichmachung Ihrer KI/ML-Arbeitslasten die detaillierte Kontrolle, Skalierbarkeit, Robustheit, Übertragbarkeit und Kosteneffizienz von verwaltetem Kubernetes 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 Bereitstellungslösung Vertex AI zu testen.

Hintergrund

Wenn Sie Gemma mithilfe von GPUs in GKE mit TGI 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 dieser Anleitung werden die folgenden Modelle vorgestellt:

• Mit Gemma können Sie diese Modelle auch optimieren, um sich auf bestimmte Aufgaben zu spezialisieren.
• CodeGemma ist eine Sammlung leistungsstarker, einfacher Modelle, die eine Vielzahl von Programmieraufgaben ausführen können, z. B. das Ausfüllen von Code in der Mitte, Codegenerierung, Natural Language Understanding, mathematische Begründungen und Anweisungen.

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

Inferenz der Textgenerierung (Text Generation Inference, TGI)

TGI ist das Toolkit von Hugging Face zum Bereitstellen und Bereitstellen von LLMs. TGI ermöglicht eine leistungsstarke Textgenerierung für beliebte Open-Source-LLMs, einschließlich Gemma. TGI bietet unter anderem:

• Optimierte Transformer-Implementierung mit Flash Attention und PagedAttention
• Kontinuierliche Batchverarbeitung zur Verbesserung des allgemeinen Bereitstellungsdurchsatzes
• Tensor-Parallelität für schnellere Inferenz auf mehreren GPUs

Weitere Informationen finden Sie in der TGI-Dokumentation.

Ziele

Dieser Leitfaden richtet sich an Kunden von generativer KI, die PyTorch verwenden, neue oder bestehende Nutzer von GKE, ML-Entwickler, MLOps-Entwickler (DevOps) oder Plattformadministratoren, die daran interessiert sind, Funktionen zur Kubernetes-Containerorchestrierung für die Bereitstellung 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. TGI in Ihrem Cluster bereitstellen.
3. TGI verwenden, um das Gemma 2-Modell über curl und eine Webchat-Oberfläche bereitzustellen.

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.

  Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the 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.

  Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the 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.

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 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 Read 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 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=tgi
   export HF_TOKEN=HF_TOKEN
   

   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.

Google Cloud-Ressourcen erstellen und konfigurieren

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

Hinweis: Für die Nutzung einiger Beschleuniger müssen Sie möglicherweise eine Kapazitätsreservierung erstellen. Informationen zum Reservieren und Verbrauchen reservierter Ressourcen finden Sie unter Reservierte zonale Ressourcen aufnehmen.

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

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:

   Gemma 2 2B

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

   GKE erstellt einen einzelnen Knotenpool mit einer L4-GPU für jeden Knoten.

   Gemma 2 9B

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

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

   Gemma 2 27B

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

   GKE erstellt einen einzelnen Knotenpool mit vier 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 -
   

TGI bereitstellen

In diesem Abschnitt stellen Sie den TGI-Container für das Gemma-Modell bereit, das Sie verwenden möchten.

Gemma 2 2B-it

Folgen Sie dieser Anleitung, um das für die Anleitung abgestimmte Modell Gemma 2B bereitzustellen.

1. Erstellen Sie das folgende tgi-2-2b-it.yaml-Manifest:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: tgi-gemma-deployment
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: gemma-server
     template:
       metadata:
         labels:
           app: gemma-server
           ai.gke.io/model: gemma-2-2b-it
           ai.gke.io/inference-server: text-generation-inference
           examples.ai.gke.io/source: user-guide
       spec:
         containers:
         - name: inference-server
           image: us-docker.pkg.dev/deeplearning-platform-release/gcr.io/huggingface-text-generation-inference-cu121.2-1.ubuntu2204.py310
           resources:
             requests:
               cpu: "2"
               memory: "10Gi"
               ephemeral-storage: "10Gi"
               nvidia.com/gpu: "1"
             limits:
               cpu: "2"
               memory: "10Gi"
               ephemeral-storage: "10Gi"
               nvidia.com/gpu: "1"
           env:
           - name: AIP_HTTP_PORT
             value: '8000'
           - name: NUM_SHARD
             value: '1'
           - name: MAX_INPUT_LENGTH
             value: '1562'
           - name: MAX_TOTAL_TOKENS
             value: '2048'
           - name: MAX_BATCH_PREFILL_TOKENS
             value: '2048'
           - name: CUDA_MEMORY_FRACTION
             value: '0.93'
           - name: MODEL_ID
             value: google/gemma-2-2b-it
           - 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. Wenden Sie das Manifest an:

   kubectl apply -f tgi-2-2b-it.yaml
   

Gemma 2 9B-it

Folgen Sie dieser Anleitung, um das für die Anleitung abgestimmte Modell Gemma 9B bereitzustellen.

1. Erstellen Sie das folgende tgi-2-9b-it.yaml-Manifest:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: tgi-gemma-deployment
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: gemma-server
     template:
       metadata:
         labels:
           app: gemma-server
           ai.gke.io/model: gemma-2-9b-it
           ai.gke.io/inference-server: text-generation-inference
           examples.ai.gke.io/source: user-guide
       spec:
         containers:
         - name: inference-server
           image: us-docker.pkg.dev/deeplearning-platform-release/gcr.io/huggingface-text-generation-inference-cu121.2-1.ubuntu2204.py310
           resources:
             requests:
               cpu: "4"
               memory: "30Gi"
               ephemeral-storage: "30Gi"
               nvidia.com/gpu: "2"
             limits:
               cpu: "4"
               memory: "30Gi"
               ephemeral-storage: "30Gi"
               nvidia.com/gpu: "2"
           env:
           - name: AIP_HTTP_PORT
             value: '8000'
           - name: NUM_SHARD
             value: '2'
           - name: MAX_INPUT_LENGTH
             value: '1562'
           - name: MAX_TOTAL_TOKENS
             value: '2048'
           - name: MAX_BATCH_PREFILL_TOKENS
             value: '2048'
           - name: CUDA_MEMORY_FRACTION
             value: '0.93'
           - name: MODEL_ID
             value: google/gemma-2-9b-it
           - 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. Wenden Sie das Manifest an:

   kubectl apply -f tgi-2-9b-it.yaml
   

Gemma 2 27B-it

Folgen Sie dieser Anleitung, um das für die Anleitung abgestimmte Modell Gemma 2 27B bereitzustellen.

1. Erstellen Sie das folgende tgi-2-27b-it.yaml-Manifest:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: tgi-gemma-deployment
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: gemma-server
     template:
       metadata:
         labels:
           app: gemma-server
           ai.gke.io/model: gemma-2-27b-it
           ai.gke.io/inference-server: text-generation-inference
           examples.ai.gke.io/source: user-guide
       spec:
         containers:
         - name: inference-server
           image: us-docker.pkg.dev/deeplearning-platform-release/gcr.io/huggingface-text-generation-inference-cu121.2-1.ubuntu2204.py310
           resources:
             requests:
               cpu: "10"
               memory: "80Gi"
               ephemeral-storage: "80Gi"
               nvidia.com/gpu: "4"
             limits:
               cpu: "10"
               memory: "80Gi"
               ephemeral-storage: "80Gi"
               nvidia.com/gpu: "4"
           env:
           - name: AIP_HTTP_PORT
             value: '8000'
           - name: NUM_SHARD
             value: '4'
           - name: MAX_INPUT_LENGTH
             value: '1562'
           - name: MAX_TOTAL_TOKENS
             value: '2048'
           - name: MAX_BATCH_PREFILL_TOKENS
             value: '2048'
           - name: CUDA_MEMORY_FRACTION
             value: '0.93'
           - name: MODEL_ID
             value: google/gemma-2-27b-it
           - 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. Wenden Sie das Manifest an:

   kubectl apply -f tgi-2-27b-it.yaml
   

CodeGemma 7B-it

Folgen Sie dieser Anleitung, um das für die Anleitung abgestimmte Modell Gemma 7B bereitzustellen.

1. Erstellen Sie das folgende tgi-codegemma-1.1-7b-it.yaml-Manifest:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: tgi-gemma-deployment
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: gemma-server
     template:
       metadata:
         labels:
           app: gemma-server
           ai.gke.io/model: codegemma-1.1-7b-it
           ai.gke.io/inference-server: text-generation-inference
           examples.ai.gke.io/source: user-guide
       spec:
         containers:
         - name: inference-server
           image: ghcr.io/huggingface/text-generation-inference:2.0.2
           resources:
             requests:
               cpu: "2"
               memory: "25Gi"
               ephemeral-storage: "40Gi"
               nvidia.com/gpu: 2
             limits:
               cpu: "10"
               memory: "25Gi"
               ephemeral-storage: "40Gi"
               nvidia.com/gpu: 2
           args:
           - --model-id=$(MODEL_ID)
           - --num-shard=2
           env:
           - name: MODEL_ID
             value: google/codegemma-1.1-7b-it
           - name: PORT
             value: "8000"
           - 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. Wenden Sie das Manifest an:

   kubectl apply -f tgi-codegemma-1.1-7b-it.yaml
   

Modell bereitstellen

In diesem Abschnitt interagieren Sie mit dem Modell.

Portweiterleitung einrichten

Führen Sie 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

In diesem Abschnitt wird gezeigt, wie Sie einen einfachen Smoke Test machen, um Ihre bereitgestellten vortrainierten oder instruierten Modelle zu prüfen. Der Einfachheit halber wird in diesem Abschnitt der Testansatz mit dem für die Anleitung abgestimmten Gemma 2- und dem CodeGemma-Modell beschrieben.

Gemma 2

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

USER_PROMPT="I'm new to coding. If you could only recommend one programming language to start with, what would it be and why?"

curl -X POST http://localhost:8000/generate \
  -H "Content-Type: application/json" \
  -d @- <<EOF
{
    "inputs": "<start_of_turn>user\n${USER_PROMPT}<end_of_turn>\n",
    "parameters": {
        "temperature": 0.90,
        "top_p": 0.95,
        "max_new_tokens": 128
    }
}
EOF

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

{"generated_text":"**Python**\n\n**Reasons why Python is a great choice for beginners:**\n\n* **Simple syntax:** Python uses clear and concise syntax, making it easy for beginners to pick up.\n* **Easy to learn:** Python's syntax is based on English, making it easier to learn than other languages.\n* **Large and supportive community:** Python has a massive and active community of developers who are constantly willing to help.\n* **Numerous libraries and tools:** Python comes with a vast collection of libraries and tools that make it easy to perform various tasks, such as data manipulation, web development, and machine learning.\n* **"}

CodeGemma

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

USER_PROMPT="Generate a python code example of a adding two numbers from a function called addNumbers"

curl -s -X POST http://localhost:8000/generate \
  -H "Content-Type: application/json" \
  -d @- <<EOF | jq -r .generated_text
{
    "inputs": "<start_of_turn>user\n${USER_PROMPT}<end_of_turn>\n",
    "parameters": {
        "temperature": 0.90,
        "top_p": 0.95,
        "max_new_tokens": 2000
    }
}
EOF

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

def addNumbers(num1, num2):
  sum = num1 + num2
  return sum

# Get the input from the user
num1 = float(input("Enter the first number: "))
num2 = float(input("Enter the second number: "))

# Call the addNumbers function
sum = addNumbers(num1, num2)

# Print the result
print("The sum of", num1, "and", num2, "is", sum)

Erfolg: Sie haben Gemma mithilfe von GPUs in GKE mit TGI bereitgestellt. Sie können jetzt mit dem Modell interagieren.

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. Der Einfachheit halber wird in diesem Abschnitt nur der Testansatz mit dem 2B-it-Modell beschrieben.

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: "250m"
               memory: "512Mi"
             limits:
               cpu: "500m"
               memory: "512Mi"
           env:
           - name: CONTEXT_PATH
             value: "/generate"
           - name: HOST
             value: "http://llm-service:8000"
           - name: LLM_ENGINE
             value: "tgi"
           - 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

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

• GPUs in GKE
• Gemma mit TGI auf anderen Beschleunigern verwenden, einschließlich A100- und H100-GPUs, indem Sie den Beispielcode in GitHub aufrufen.
• GPU-Arbeitslasten in Autopilot bereitstellen
• GPU-Arbeitslasten in Standard bereitstellen
• TGI-Dokumentation lesen.
• Erfahren Sie mehr über den Vertex AI Model Garden.
• Erfahren Sie, wie Sie optimierte KI-/ML-Arbeitslasten über Funktionen zur GKE-Plattformorchestrierung ausführen.