LLM mit mehreren GPUs in GKE bereitstellen

Autopilot Standard

---

In dieser Anleitung wird beschrieben, wie Sie ein großes Sprachmodell (LLM) mit GPUs in Google Kubernetes Engine (GKE) bereitstellen. In dieser Anleitung wird ein GKE-Cluster erstellt, der mehrere L4-GPUs verwendet, und die GKE-Infrastruktur für die Bereitstellung eines der folgenden Modelle vorbereitet:

• Llama 2 70b
• Mixtral 8x7b
• Falcon 40b

Je nach Datenformat des Modells variiert die Anzahl der GPUs. In dieser Anleitung verwendet jedes Modell zwei L4-GPUs. Weitere Informationen finden Sie unter Anzahl der GPUs berechnen.

Bevor Sie diese Anleitung in GKE ausführen, lesen Sie die Informationen zu GPUs in GKE.

Lernziele

Diese Anleitung richtet sich an MLOps- oder DevOps-Entwickler oder Plattformadministratoren, die GKE-Orchestrierungsfunktionen zum Bereitstellen von LLMs verwenden möchten.

Diese Anleitung umfasst die folgenden Schritte:

1. Cluster und Knotenpools erstellen
2. Bereiten Sie Ihre Arbeitslast vor.
3. Stellen Sie Ihre Arbeitslast bereit.
4. Mit der LLM-Benutzeroberfläche interagieren

Hinweise

Führen Sie die folgenden Aufgaben aus, bevor Sie beginnen:

• Aktivieren Sie die Google Kubernetes Engine API.
Google Kubernetes Engine API aktivieren
• Wenn Sie die Google Cloud CLI für diese Aufgabe verwenden möchten, müssen Sie die gcloud CLI installieren und dann initialisieren. Wenn Sie die gcloud CLI bereits installiert haben, rufen Sie die neueste Version mit gcloud components update ab.
  Hinweis: Legen Sie für vorhandene Installationen der gcloud CLI die compute/region- und compute/zone-Attribute fest. Durch das Festlegen von Standardspeicherorten können Sie in der gcloud CLI Fehler wie One of [--zone, --region] must be supplied: Please specify location vermeiden.

• Einige Modelle haben zusätzliche Anforderungen. Folgende Anforderungen müssen erfüllt sein:

  • Verwenden Sie ein HuggingFace-Token, um auf Modelle über Hugging Face zuzugreifen.
  • Akzeptieren Sie für das Mixtral 8x7b-Modell die Bedingungen für das Mistral Mixtral-Modell.
  • Für das Llama 2 70b-Modell benötigen Sie eine aktive Lizenz für die Meta Llama-Modelle.
  Warnung: Der Zugriff und die Genehmigung für das Llama-Modell kann bis zu drei Tage dauern.

Umgebung vorbereiten

1. Starten Sie in der Google Cloud Console eine Cloud Shell-Instanz:
   Cloud Shell öffnen

2. Legen Sie die Standardumgebungsvariablen fest:

   gcloud config set project PROJECT_ID
   export PROJECT_ID=$(gcloud config get project)
   export REGION=us-central1
   

   Ersetzen Sie PROJECT_ID durch Ihre Google Cloud-Projekt-ID.

   Hinweis: Wenn Ihre Cloud Shell-Instanz während der Ausführung der Anleitung getrennt wird, wiederholen Sie den vorherigen Schritt.

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

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

   gcloud container clusters create-auto l4-demo \
     --project=${PROJECT_ID} \
     --region=${REGION} \
     --release-channel=rapid
   

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

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

   gcloud container clusters get-credentials l4-demo --region=${REGION}
   

Standard

1. Führen Sie in Cloud Shell den folgenden Befehl aus, um einen Standardcluster zu erstellen, der Workload Identity-Föderation für GKE nutzt:

   gcloud container clusters create l4-demo --location ${REGION} \
     --workload-pool ${PROJECT_ID}.svc.id.goog \
     --enable-image-streaming \
     --node-locations=$REGION-a \
     --workload-pool=${PROJECT_ID}.svc.id.goog \
     --machine-type n2d-standard-4 \
     --num-nodes 1 --min-nodes 1 --max-nodes 5 \
     --release-channel=rapid
   

   Hinweis: Das Flag --node-locations muss möglicherweise entsprechend der ausgewählten Region angepasst werden. Prüfen Sie, welche Zonen die L4-GPUs verfügbar sind, wenn Sie die Region us-central1 ändern.

   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 g2-standard-24 --cluster l4-demo \
     --accelerator type=nvidia-l4,count=2,gpu-driver-version=latest \
     --machine-type g2-standard-24 \
     --enable-autoscaling --enable-image-streaming \
     --num-nodes=0 --min-nodes=0 --max-nodes=3 \
     --node-locations $REGION-a,$REGION-c --region $REGION --spot
   

   GKE erstellt die folgenden Ressourcen für das LLM:

   • Ein öffentlicher Cluster der Google Kubernetes Engine (GKE) Standard Edition.
   • Ein Knotenpool mit dem Maschinentyp g2-standard-24, der auf 0 Knoten herunterskaliert wird. Ihnen werden keine GPUs in Rechnung gestellt, bis Sie Pods starten, die GPUs anfordern. Dieser Knotenpool bietet Spot-VMs, die günstiger als Standard-VMs von Compute Engine sind und keine Verfügbarkeit versprechen. Sie können das Flag --spot aus diesem Befehl und den Knotenselektor cloud.google.com/gke-spot in der Konfiguration text-generation-inference.yaml entfernen, um On-Demand-VMs zu verwenden.

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

   gcloud container clusters get-credentials l4-demo --region=${REGION}
   

Arbeitslast vorbereiten

Im folgenden Abschnitt wird gezeigt, wie Sie Ihre Arbeitslast abhängig vom Modell einrichten:

Llama 2 70b

1. Legen Sie die Standardumgebungsvariablen fest:

   export HF_TOKEN=HUGGING_FACE_TOKEN
   

   Ersetzen Sie HUGGING_FACE_TOKEN durch Ihr Hive-Face-Token.

2. Erstellen Sie ein Kubernetes-Secret für das HuggingFace-Token:

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

3. Erstellen Sie das folgende text-generation-inference.yaml-Manifest:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: llm
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: llm
     template:
       metadata:
         labels:
           app: llm
       spec:
         containers:
         - name: llm
           image: ghcr.io/huggingface/text-generation-inference:1.4.3
           resources:
             requests:
               cpu: "10"
               memory: "60Gi"
               nvidia.com/gpu: "2"
             limits:
               cpu: "10"
               memory: "60Gi"
               nvidia.com/gpu: "2"
           env:
           - name: MODEL_ID
             value: meta-llama/Llama-2-70b-chat-hf
           - name: NUM_SHARD
             value: "2"
           - name: PORT
             value: "8080"
           - name: QUANTIZE
             value: bitsandbytes-nf4
           - name: HUGGING_FACE_HUB_TOKEN
             valueFrom:
               secretKeyRef:
                 name: l4-demo
                 key: HUGGING_FACE_TOKEN
           volumeMounts:
             - mountPath: /dev/shm
               name: dshm
             - mountPath: /data
               name: ephemeral-volume
         volumes:
           - name: dshm
             emptyDir:
                 medium: Memory
           - name: ephemeral-volume
             ephemeral:
               volumeClaimTemplate:
                 metadata:
                   labels:
                     type: ephemeral
                 spec:
                   accessModes: ["ReadWriteOnce"]
                   storageClassName: "premium-rwo"
                   resources:
                     requests:
                       storage: 150Gi
         nodeSelector:
           cloud.google.com/gke-accelerator: "nvidia-l4"
           cloud.google.com/gke-spot: "true"

   In diesem Manifest:

   • Für NUM_SHARD muss 2 festgelegt sein, da das Modell zwei NVIDIA L4-GPUs benötigt.
   • QUANTIZE ist auf bitsandbytes-nf4 gesetzt, was bedeutet, dass das Modell mit 4 Bit anstelle von 32 Bit geladen wird. Dadurch kann GKE den benötigten GPU-Arbeitsspeicher reduzieren und die Inferenzgeschwindigkeit verbessern. Die Genauigkeit des Modells kann jedoch sinken. Informationen zum Berechnen der angeforderten GPUs finden Sie unter Anzahl der GPUs berechnen.

4. Wenden Sie das Manifest an:

   kubectl apply -f text-generation-inference.yaml
   

   Die Ausgabe sieht in etwa so aus:

   deployment.apps/llm created
   

5. Prüfen Sie den Status des Modells:

   kubectl get deploy
   

   Die Ausgabe sieht in etwa so aus:

   NAME          READY   UP-TO-DATE   AVAILABLE   AGE
   llm           1/1     1            1           20m
   

6. So rufen Sie die Logs aus der laufenden Bereitstellung auf:

   kubectl logs -l app=llm
   

   Die Ausgabe sieht in etwa so aus:

   {"timestamp":"2024-03-09T05:08:14.751646Z","level":"INFO","message":"Warming up model","target":"text_generation_router","filename":"router/src/main.rs","line_number":291}
   {"timestamp":"2024-03-09T05:08:19.961136Z","level":"INFO","message":"Setting max batch total tokens to 133696","target":"text_generation_router","filename":"router/src/main.rs","line_number":328}
   {"timestamp":"2024-03-09T05:08:19.961164Z","level":"INFO","message":"Connected","target":"text_generation_router","filename":"router/src/main.rs","line_number":329}
   {"timestamp":"2024-03-09T05:08:19.961171Z","level":"WARN","message":"Invalid hostname, defaulting to 0.0.0.0","target":"text_generation_router","filename":"router/src/main.rs","line_number":343}
   

Mixtral 8x7b

1. Legen Sie die Standardumgebungsvariablen fest:

   export HF_TOKEN=HUGGING_FACE_TOKEN
   

   Ersetzen Sie HUGGING_FACE_TOKEN durch Ihr Hive-Face-Token.

2. Erstellen Sie ein Kubernetes-Secret für das HuggingFace-Token:

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

3. Erstellen Sie das folgende text-generation-inference.yaml-Manifest:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: llm
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: llm
     template:
       metadata:
         labels:
           app: llm
       spec:
         containers:
         - name: llm
           image: ghcr.io/huggingface/text-generation-inference:1.4.3
           resources:
             requests:
               cpu: "5"
               memory: "40Gi"
               nvidia.com/gpu: "2"
             limits:
               cpu: "5"
               memory: "40Gi"
               nvidia.com/gpu: "2"
           env:
           - name: MODEL_ID
             value: mistralai/Mixtral-8x7B-Instruct-v0.1
           - name: NUM_SHARD
             value: "2"
           - name: PORT
             value: "8080"
           - name: QUANTIZE
             value: bitsandbytes-nf4
           - name: HUGGING_FACE_HUB_TOKEN
             valueFrom:
               secretKeyRef:
                 name: l4-demo
                 key: HUGGING_FACE_TOKEN
           volumeMounts:
             - mountPath: /dev/shm
               name: dshm
             - mountPath: /data
               name: ephemeral-volume
         volumes:
           - name: dshm
             emptyDir:
                 medium: Memory
           - name: ephemeral-volume
             ephemeral:
               volumeClaimTemplate:
                 metadata:
                   labels:
                     type: ephemeral
                 spec:
                   accessModes: ["ReadWriteOnce"]
                   storageClassName: "premium-rwo"
                   resources:
                     requests:
                       storage: 100Gi
         nodeSelector:
           cloud.google.com/gke-accelerator: "nvidia-l4"
           cloud.google.com/gke-spot: "true"

   In diesem Manifest:

   • Für NUM_SHARD muss 2 festgelegt sein, da das Modell zwei NVIDIA L4-GPUs benötigt.
   • QUANTIZE ist auf bitsandbytes-nf4 gesetzt, was bedeutet, dass das Modell mit 4 Bit anstelle von 32 Bit geladen wird. Dadurch kann GKE die benötigte GPU-Arbeitsspeichermenge reduzieren und die Inferenzgeschwindigkeit verbessern. Dies kann jedoch die Modellgenauigkeit beeinträchtigen. Informationen zur Berechnung der angeforderten GPUs finden Sie unter Anzahl der GPUs berechnen.

4. Wenden Sie das Manifest an:

   kubectl apply -f text-generation-inference.yaml
   

   Die Ausgabe sieht in etwa so aus:

   deployment.apps/llm created
   

5. Prüfen Sie den Status des Modells:

   watch kubectl get deploy
   

   Die Ausgabe sieht in etwa so aus, wenn die Bereitstellung bereit ist: Geben Sie CTRL + C ein, um die Beobachtung zu beenden.

   NAME          READY   UP-TO-DATE   AVAILABLE   AGE
   llm           1/1     1            1           10m
   

6. So rufen Sie die Logs aus der laufenden Bereitstellung auf:

   kubectl logs -l app=llm
   

   Die Ausgabe sieht in etwa so aus:

   {"timestamp":"2024-03-09T05:08:14.751646Z","level":"INFO","message":"Warming up model","target":"text_generation_router","filename":"router/src/main.rs","line_number":291}
   {"timestamp":"2024-03-09T05:08:19.961136Z","level":"INFO","message":"Setting max batch total tokens to 133696","target":"text_generation_router","filename":"router/src/main.rs","line_number":328}
   {"timestamp":"2024-03-09T05:08:19.961164Z","level":"INFO","message":"Connected","target":"text_generation_router","filename":"router/src/main.rs","line_number":329}
   {"timestamp":"2024-03-09T05:08:19.961171Z","level":"WARN","message":"Invalid hostname, defaulting to 0.0.0.0","target":"text_generation_router","filename":"router/src/main.rs","line_number":343}
   

Falcon 40b

1. Erstellen Sie das folgende text-generation-inference.yaml-Manifest:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: llm
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: llm
     template:
       metadata:
         labels:
           app: llm
       spec:
         containers:
         - name: llm
           image: ghcr.io/huggingface/text-generation-inference:1.4.3
           resources:
             requests:
               cpu: "10"
               memory: "60Gi"
               nvidia.com/gpu: "2"
             limits:
               cpu: "10"
               memory: "60Gi"
               nvidia.com/gpu: "2"
           env:
           - name: MODEL_ID
             value: tiiuae/falcon-40b-instruct
           - name: NUM_SHARD
             value: "2"
           - name: PORT
             value: "8080"
           - name: QUANTIZE
             value: bitsandbytes-nf4
           volumeMounts:
             - mountPath: /dev/shm
               name: dshm
             - mountPath: /data
               name: ephemeral-volume
         volumes:
           - name: dshm
             emptyDir:
                 medium: Memory
           - name: ephemeral-volume
             ephemeral:
               volumeClaimTemplate:
                 metadata:
                   labels:
                     type: ephemeral
                 spec:
                   accessModes: ["ReadWriteOnce"]
                   storageClassName: "premium-rwo"
                   resources:
                     requests:
                       storage: 175Gi
         nodeSelector:
           cloud.google.com/gke-accelerator: "nvidia-l4"
           cloud.google.com/gke-spot: "true"

   In diesem Manifest:

   • Für NUM_SHARD muss 2 festgelegt sein, da das Modell zwei NVIDIA L4-GPUs benötigt.
   • QUANTIZE ist auf bitsandbytes-nf4 gesetzt, was bedeutet, dass das Modell mit 4 Bit anstelle von 32 Bit geladen wird. Dadurch kann GKE den benötigten GPU-Arbeitsspeicher reduzieren und die Inferenzgeschwindigkeit verbessern. Die Genauigkeit des Modells kann jedoch sinken. Informationen zum Berechnen der angeforderten GPUs finden Sie unter Anzahl der GPUs berechnen.

2. Wenden Sie das Manifest an:

   kubectl apply -f text-generation-inference.yaml
   

   Die Ausgabe sieht in etwa so aus:

   deployment.apps/llm created
   

3. Prüfen Sie den Status des Modells:

   watch kubectl get deploy
   

   Die Ausgabe sieht in etwa so aus, wenn die Bereitstellung bereit ist: Geben Sie CTRL + C ein, um die Beobachtung zu beenden.

   NAME          READY   UP-TO-DATE   AVAILABLE   AGE
   llm           1/1     1            1           10m
   

4. So rufen Sie die Logs aus der laufenden Bereitstellung auf:

   kubectl logs -l app=llm
   

   Die Ausgabe sieht in etwa so aus:

   {"timestamp":"2024-03-09T05:08:14.751646Z","level":"INFO","message":"Warming up model","target":"text_generation_router","filename":"router/src/main.rs","line_number":291}
   {"timestamp":"2024-03-09T05:08:19.961136Z","level":"INFO","message":"Setting max batch total tokens to 133696","target":"text_generation_router","filename":"router/src/main.rs","line_number":328}
   {"timestamp":"2024-03-09T05:08:19.961164Z","level":"INFO","message":"Connected","target":"text_generation_router","filename":"router/src/main.rs","line_number":329}
   {"timestamp":"2024-03-09T05:08:19.961171Z","level":"WARN","message":"Invalid hostname, defaulting to 0.0.0.0","target":"text_generation_router","filename":"router/src/main.rs","line_number":343}
   

Service vom Typ ClusterIP erstellen

1. Erstellen Sie das folgende llm-service.yaml-Manifest:

   apiVersion: v1
   kind: Service
   metadata:
     name: llm-service
   spec:
     selector:
       app: llm
     type: ClusterIP
     ports:
       - protocol: TCP
         port: 80
         targetPort: 8080
   

2. Wenden Sie das Manifest an:

   kubectl apply -f llm-service.yaml
   

Chatoberfläche bereitstellen

Mit Gradio erstellen Sie eine Webanwendung, die Ihnen die Interaktion mit Ihrem Modell ermöglicht. Gradio ist eine Python-Bibliothek mit einem ChatInterface-Wrapper, der Benutzeroberflächen für Chatbots erstellt.

Llama 2 70b

1. Erstellen Sie eine Datei mit dem Namen gradio.yaml.

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: gradio
     labels:
       app: gradio
   spec:
     strategy:
       type: Recreate
     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.0
           resources:
             requests:
               cpu: "512m"
               memory: "512Mi"
             limits:
               cpu: "1"
               memory: "512Mi"
           env:
           - name: CONTEXT_PATH
             value: "/generate"
           - name: HOST
             value: "http://llm-service"
           - name: LLM_ENGINE
             value: "tgi"
           - name: MODEL_ID
             value: "llama-2-70b"
           - name: USER_PROMPT
             value: "[INST] prompt [/INST]"
           - name: SYSTEM_PROMPT
             value: "prompt"
           ports:
           - containerPort: 7860
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: gradio-service
   spec:
     type: LoadBalancer
     selector:
       app: gradio
     ports:
     - port: 80
       targetPort: 7860

2. Wenden Sie das Manifest an:

   kubectl apply -f gradio.yaml
   

3. Suchen Sie die externe IP-Adresse des Dienstes:

   kubectl get svc
   

   Die Ausgabe sieht in etwa so aus:

   NAME             TYPE           CLUSTER-IP     EXTERNAL-IP     PORT(S)        AGE
   gradio-service   LoadBalancer   10.24.29.197   34.172.115.35   80:30952/TCP   125m
   

4. Kopieren Sie die externe IP-Adresse aus der Spalte EXTERNAL-IP.

5. Rufen Sie die Modellschnittstelle in Ihrem Webbrowser auf. Geben Sie dazu die externe IP-Adresse mit dem freigegebenen Port ein:

   http://EXTERNAL_IP
   

Mixtral 8x7b

1. Erstellen Sie eine Datei mit dem Namen gradio.yaml:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: gradio
     labels:
       app: gradio
   spec:
     strategy:
       type: Recreate
     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.0
           resources:
             requests:
               cpu: "512m"
               memory: "512Mi"
             limits:
               cpu: "1"
               memory: "512Mi"
           env:
           - name: CONTEXT_PATH
             value: "/generate"
           - name: HOST
             value: "http://llm-service"
           - name: LLM_ENGINE
             value: "tgi"
           - name: MODEL_ID
             value: "mixtral-8x7b"
           - name: USER_PROMPT
             value: "[INST] prompt [/INST]"
           - name: SYSTEM_PROMPT
             value: "prompt"
           ports:
           - containerPort: 7860
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: gradio-service
   spec:
     type: LoadBalancer
     selector:
       app: gradio
     ports:
     - port: 80
       targetPort: 7860

2. Wenden Sie das Manifest an:

   kubectl apply -f gradio.yaml
   

3. Suchen Sie die externe IP-Adresse des Dienstes:

   kubectl get svc
   

   Die Ausgabe sieht in etwa so aus:

   NAME             TYPE           CLUSTER-IP     EXTERNAL-IP     PORT(S)        AGE
   gradio-service   LoadBalancer   10.24.29.197   34.172.115.35   80:30952/TCP   125m
   

4. Kopieren Sie die externe IP-Adresse aus der Spalte EXTERNAL-IP.

5. Rufen Sie die Modellschnittstelle in Ihrem Webbrowser auf. Geben Sie dazu die externe IP-Adresse mit dem freigegebenen Port ein:

   http://EXTERNAL_IP
   

Falcon 40b

1. Erstellen Sie eine Datei mit dem Namen gradio.yaml.

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: gradio
     labels:
       app: gradio
   spec:
     strategy:
       type: Recreate
     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.0
           resources:
             requests:
               cpu: "512m"
               memory: "512Mi"
             limits:
               cpu: "1"
               memory: "512Mi"
           env:
           - name: CONTEXT_PATH
             value: "/generate"
           - name: HOST
             value: "http://llm-service"
           - name: LLM_ENGINE
             value: "tgi"
           - name: MODEL_ID
             value: "falcon-40b-instruct"
           - name: USER_PROMPT
             value: "User: prompt"
           - name: SYSTEM_PROMPT
             value: "Assistant: prompt"
           ports:
           - containerPort: 7860
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: gradio-service
   spec:
     type: LoadBalancer
     selector:
       app: gradio
     ports:
     - port: 80
       targetPort: 7860

2. Wenden Sie das Manifest an:

   kubectl apply -f gradio.yaml
   

3. Suchen Sie die externe IP-Adresse des Dienstes:

   kubectl get svc
   

   Die Ausgabe sieht in etwa so aus:

   NAME             TYPE           CLUSTER-IP     EXTERNAL-IP     PORT(S)        AGE
   gradio-service   LoadBalancer   10.24.29.197   34.172.115.35   80:30952/TCP   125m
   

4. Kopieren Sie die externe IP-Adresse aus der Spalte EXTERNAL-IP.

5. Rufen Sie die Modellschnittstelle in Ihrem Webbrowser auf. Geben Sie dazu die externe IP-Adresse mit dem freigegebenen Port ein:

   http://EXTERNAL_IP
   

Erfolgreich: Sie haben jetzt eine LLM mit L4-GPUs in GKE bereitgestellt.

Anzahl der GPUs berechnen

Die Anzahl der GPUs hängt vom Wert des Flags QUANTIZE ab. In dieser Anleitung ist QUANTIZE auf bitsandbytes-nf4 gesetzt, was bedeutet, dass das Modell in 4 Bit geladen wird.

Ein Parametermodell mit 70 Milliarden Attributen würde mindestens 40 GB GPU-Arbeitsspeicher benötigen, was 70 Milliarden Mal 4 Bit (70 Milliarden x 4 Bits= 35 GB) entspricht und 5 GB Overhead berücksichtigt. In diesem Fall hätte eine einzelne L4-GPU nicht genügend Arbeitsspeicher. Daher werden in den Beispielen dieser Anleitung zwei L4-GPUs des Arbeitsspeichers (2 x 24 = 48 GB) verwendet. Diese Konfiguration ist ausreichend, um Falcon 40b oder Llama 2 70b in L4-GPUs auszuführen.

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.

Cluster löschen

Löschen Sie den GKE-Cluster, damit Ihrem Google Cloud-Konto die in dieser Anleitung erstellten Ressourcen nicht in Rechnung gestellt werden.

gcloud container clusters delete l4-demo --region ${REGION}

Nächste Schritte

• Weitere Informationen zu G2-VMs mit NVIDIA L4-GPUs
• Modell mit GPUs im GKE Standard-Modus trainieren