LLM auf L4-GPUs mit Ray bereitstellen

Autopilot Standard

---

In dieser Anleitung wird beschrieben, wie Sie große Sprachmodelle (LLM) mit dem Ray-Framework in dem GKE-Modus (Google Kubernetes Engine) bereitstellen. Diese Anleitung richtet sich an MLOps- oder DevOps-Entwickler oder Plattformadministratoren, die GKE-Orchestrierungsfunktionen zum Bereitstellen von LLMs verwenden möchten.

In dieser Anleitung können Sie eines der folgenden Modelle bereitstellen:

• Falcon 7b
• Llama2 7b
• Falcon 40b
• Llama2 70b

Bevor Sie die folgenden Schritte in GKE ausführen, sollten Sie die Informationen zu GPUs in GKE lesen.

Hintergrund

Das Ray-Framework bietet eine End-to-End-KI-/ML-Plattform für Training, fine-Training und Ableitung von ML-Arbeitslasten. 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.

Der Leitfaden behandelt folgende Schritte:

1. Autopilot- oder Standard-GKE-Cluster erstellen
2. Stellen Sie den KubeRay-Operator bereit.
3. Stellen Sie benutzerdefinierte RayService-Ressourcen für die Bereitstellung von LLMs bereit.

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.

• Wenn Sie das Llama 2-Modell verwenden möchten, benötigen Sie Folgendes:

  • Zugriff auf eine aktive Lizenz für die Meta Llama-Modelle.
  • Ein HuggingFace-Token.
  Warnung: Der Zugriff und die Genehmigung für das Llama-Modell kann bis zu drei Tage dauern.

• Sie benötigen ein GPU-Kontingent in der Region us-central1. Weitere Informationen finden Sie unter GPU-Kontingent.

Umgebung vorbereiten

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

2. Klonen Sie das Beispiel-Repository:

   git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples.git
   cd kubernetes-engine-samples/ai-ml/gke-ray
   export TUTORIAL_HOME=`pwd`
   

   Dieses Repository enthält das vordefinierte Container-Image ray-llm, das verschiedene Beschleunigertypen bereitstellt. In dieser Anleitung verwenden Sie NVIDIA L4-GPUs. Daher verweist spec.serveConfigV2 in RayService auf ein Repository mit Modellen, die den L4-Beschleunigertyp verwenden.

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

Cluster und GPU-Knotenpool erstellen

Sie können eine LLM auf L4-GPUs mit Ray in einem GKE Autopilot- oder Standardcluster bereitstellen. Für eine vollständig verwaltete Kubernetes-Umgebung empfehlen wir die Verwendung eines Autopilot-Clusters oder eines Standard-Clusters, wenn Ihr Anwendungsfall eine hohe Skalierbarkeit erfordert oder mehr Kontrolle über die Clusterkonfiguration bietet. Informationen zum Auswählen des GKE-Betriebsmodus, der für Ihre Arbeitslasten am besten geeignet ist, finden Sie unter GKE-Betriebsmodus auswählen.

Erledigen Sie mit Cloud Shell Folgendes:

1. Rufen Sie den gke-platform-Ordner auf:

   cd ${TUTORIAL_HOME}/gke-platform
   

   • Führen Sie für einen Autopilot-Cluster den folgenden Befehl aus:

   cat << EOF > terraform.tfvars
   enable_autopilot=true
   project_id="${PROJECT_ID}"
   EOF
   

   • Führen Sie für einen Standardcluster den folgenden Befehl aus:

   cat << EOF > terraform.tfvars
   project_id="${PROJECT_ID}"
   gpu_pool_machine_type="g2-standard-24"
   gpu_pool_accelerator_type="nvidia-l4"
   gpu_pool_node_locations=["us-central1-a", "us-central1-c"]
   EOF
   

2. Stellen Sie den GKE-Cluster und den Knotenpool bereit:

   terraform init
   terraform apply --auto-approve
   

   Bei der Initialisierung von Terraform werden Statusmeldungen protokolliert. Am Ende der Nachrichtenausgabe wird die Meldung angezeigt, dass Terraform erfolgreich initialisiert wurde.

   Nach Abschluss des Vorgangs stellen die Terraform-Manifeste die folgenden Komponenten bereit:

   • GKE-Cluster
   • CPU-Knotenpool
   • GPU-Knotenpool
   • KubeRay-Operator mit Ray CustomResourceDefinitions (CRDs)

3. Rufen Sie die bereitgestellten Cluster-Anmeldedaten ab, die von kubectl im nächsten Abschnitt des Leitfadens verwendet werden sollen:

   gcloud container clusters get-credentials ml-cluster --region us-central1
   

4. Rufen Sie den rayserve-Ordner auf:

   cd ${TUTORIAL_HOME}/rayserve
   

LLM-Modell bereitstellen

Im geklonten Repository enthält der Ordner models die Konfiguration, die die Modelle lädt. Bei ray-llm besteht die Konfiguration für jedes Modell aus folgendem:

• Bereitstellung: Die Ray-Serve-Konfiguration
• Engine: Das Huggingface-Modell, Modellparameter, Eingabeaufforderungen
• Skalierung: Die Definition der Ray-Ressourcen, die das Modell verbraucht
• Die spezifischen Konfigurationen pro Modell

In dieser Anleitung verwenden Sie die Quantisierung von 4-Bit-NormalFloat (NF4) über die HuggingFace-Transformer, um LLMs mit reduziertem GPU-Arbeitsspeicher zu laden (zwei L4-GPUs). Dies bedeutet 48 GB GPU-Arbeitsspeicher insgesamt. Die Reduzierung von 16 Bit auf 4 Bit verringert die Gewichtung der Modelle. Sie bietet aber mehr Flexibilität, um größere Modelle zu testen und zu prüfen, ob sie für Ihren Anwendungsfall ausreichend sind. Zur Quantisierung verwendet der Beispielcode die HuggingFace- und BitsAndBytesConfig-Bibliotheken, um die quantisierten Versionen größerer Parametermodelle, Falcon 40b und Llama2 70b zu laden.

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

Hinweis: Alternativ können Sie ein Image als Teil der Pipeline erstellen und Ihre Modelle hinzufügen.

Falcon 7b

1. Stellen Sie den RayService und die Abhängigkeiten bereit. Verwenden Sie den Befehl, der dem von Ihnen erstellten GKE-Modus entspricht:

   • Autopilot:

   kubectl apply -f models/falcon-7b-instruct.yaml
   kubectl apply -f ap_pvc-rayservice.yaml
   kubectl apply -f ap_falcon-7b.yaml
   

   • Standard:

   kubectl apply -f models/falcon-7b-instruct.yaml
   kubectl apply -f falcon-7b.yaml
   

   Das Erstellen des Ray-Cluster-Pods kann einige Minuten dauern, um den Status Running zu erreichen.

2. Warten Sie, bis der Head-Pod des Ray-Clusters ausgeführt wird.

   watch --color --interval 5 --no-title \
       "kubectl get pod | \
       GREP_COLOR='01;92' egrep --color=always -e '^' -e 'Running'"
   

3. Nachdem der Ray-Cluster-Pod ausgeführt wurde, können Sie den Status des Modells prüfen:

   export HEAD_POD=$(kubectl get pods --selector=ray.io/node-type=head \
       -n default \
       -o custom-columns=POD:metadata.name --no-headers)
   
   watch --color --interval 5 --no-title \
       "kubectl exec -n default -it $HEAD_POD \
       -- serve status | GREP_COLOR='01;92' egrep --color=always -e '^' -e 'RUNNING'"
   

   Die Ausgabe sieht in etwa so aus:

   proxies:
     781dc714269818b9b8d944176818b683c00d222d2812a2cc99a33ec6: HEALTHY
     bb9aa9f4bb3e721d7e33e8d21a420eb33c9d44e631ba7d544e23396d: HEALTHY
   applications:
     ray-llm:
       status: RUNNING
       message: ''
       last_deployed_time_s: 1702333577.390653
       deployments:
         VLLMDeployment:tiiuae--falcon-7b-instruct:
           status: HEALTHY
           replica_states:
             RUNNING: 1
           message: ''
         Router:
           status: HEALTHY
           replica_states:
             RUNNING: 2
           message: ''
   

   Wenn das Feld Status RUNNING lautet, ist Ihr LLM bereit, zu chatten.

Llama2 7b

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 hf-secret \
       --from-literal=hf_api_token=${HF_TOKEN} \
       --dry-run=client -o yaml | kubectl apply -f -
   

3. Stellen Sie den RayService und die Abhängigkeiten bereit. Verwenden Sie den Befehl, der dem von Ihnen erstellten GKE-Modus entspricht:

   • Autopilot:

   kubectl apply -f models/llama2-7b-chat-hf.yaml
   kubectl apply -f ap_pvc-rayservice.yaml
   kubectl apply -f ap_llama2-7b.yaml
   

   Hinweis: Der GKE Autopilot-Cluster verwendet einen PersistentVolumeClaim, der auf dem Ray-Worker bereitgestellt wird, um das Modell zu speichern.
   • Standard:

   kubectl apply -f models/llama2-7b-chat-hf.yaml
   kubectl apply -f llama2-7b.yaml
   

   Das Erstellen des Ray-Cluster-Pods kann einige Minuten dauern, um den Status Running zu erreichen.

4. Warten Sie, bis der Head-Pod des Ray-Clusters ausgeführt wird.

   watch --color --interval 5 --no-title \
       "kubectl get pod | \
       GREP_COLOR='01;92' egrep --color=always -e '^' -e 'Running'"
   

5. Sobald der Ray-Cluster-Pod ausgeführt wird, können Sie den Status des Modells prüfen:

   export HEAD_POD=$(kubectl get pods --selector=ray.io/node-type=head \
       -n default \
       -o custom-columns=POD:metadata.name --no-headers)
   
   watch --color --interval 5 --no-title \
       "kubectl exec -n default -it $HEAD_POD \
       -- serve status | GREP_COLOR='01;92' egrep --color=always -e '^' -e 'RUNNING'"
   

   Die Ausgabe sieht in etwa so aus:

     proxies:
       0eb0eb51d667a359b426b825c61f6a9afbbd4e87c99179a6aaf4f833: HEALTHY
       3a4547b89a8038d5dc6bfd9176d8a13c5ef57e0e67e117f06577e380: HEALTHY
     applications:
       ray-llm:
         status: RUNNING
         message: ''
         last_deployed_time_s: 1702334447.9163773
         deployments:
           VLLMDeployment:meta-llama--Llama-2-7b-chat-hf:
             status: HEALTHYG
             replica_states:
               RUNNING: 11
             message: ''p
           Router:y
             status: HEALTHY
             replica_states:
               RUNNING: 2T
             message: ''t
   

   Wenn das Feld Status RUNNING lautet, ist Ihr LLM bereit, zu chatten.

Falcon 40b

1. Stellen Sie den RayService und die Abhängigkeiten bereit. Verwenden Sie den Befehl, der dem von Ihnen erstellten GKE-Modus entspricht:

   • Autopilot:

   kubectl apply -f models/quantized-model.yaml
   kubectl apply -f ap_pvc-rayservice.yaml
   kubectl apply -f ap_falcon-40b.yaml
   

   • Standard:

   kubectl apply -f models/quantized-model.yaml
   kubectl apply -f falcon-40b.yaml
   

   Es kann einige Minuten dauern, bis der Ray-Cluster-Pod den Status Running erreicht.

2. Warten Sie, bis der Head-Pod des Ray-Clusters ausgeführt wird.

   watch --color --interval 5 --no-title \
       "kubectl get pod | \
       GREP_COLOR='01;92' egrep --color=always -e '^' -e 'Running'"
   

3. Nachdem der Ray-Cluster-Pod ausgeführt wurde, können Sie den Status des Modells prüfen:

   export HEAD_POD=$(kubectl get pods --selector=ray.io/node-type=head \
       -n default \
       -o custom-columns=POD:metadata.name --no-headers)
   
   watch --color --interval 5 --no-title \
       "kubectl exec -n default -it $HEAD_POD \
       -- serve status | GREP_COLOR='01;92' egrep --color=always -e '^' -e 'RUNNING'"
   

   Die Ausgabe sieht in etwa so aus:

   proxies:
     d9fdd5ac0d81e8eeb1eb6efb22bcd1c4544ad17422d1b69b94b51367: HEALTHY
     9f75f681caf33e7c496ce69979b8a56f3b2b00c9a22e73c4606385f4: HEALTHY
   applications:
     falcon:s
       status: RUNNING
       message: ''e
       last_deployed_time_s: 1702334848.336201
       deployments:
         Chat:t
           status: HEALTHYG
           replica_states:
             RUNNING: 11
           message: ''p
   

   Wenn das Feld Status RUNNING lautet, ist Ihr LLM bereit, zu chatten.

Llama2 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 hf-secret \
       --from-literal=hf_api_token=${HF_TOKEN} \
       --dry-run=client -o yaml | kubectl apply -f -
   

3. Stellen Sie den RayService und die Abhängigkeiten bereit. Verwenden Sie den Befehl, der dem von Ihnen erstellten GKE-Modus entspricht:

   • Autopilot:

   kubectl apply -f models/quantized-model.yaml
   kubectl apply -f ap_pvc-rayservice.yaml
   kubectl apply -f ap_llama2-70b.yaml
   

   • Standard:

   kubectl apply -f models/quantized-model.yaml
   kubectl apply -f llama2-70b.yaml
   

   Es kann einige Minuten dauern, bis der Ray-Cluster-Pod den Status Running erreicht.

4. Warten Sie, bis der Head-Pod des Ray-Clusters ausgeführt wird.

   watch --color --interval 5 --no-title \
       "kubectl get pod | \
       GREP_COLOR='01;92' egrep --color=always -e '^' -e 'Running'"
   

5. Sobald der Ray-Cluster-Pod ausgeführt wird, können Sie den Status des Modells prüfen:

   export HEAD_POD=$(kubectl get pods --selector=ray.io/node-type=head \
       -n default \
       -o custom-columns=POD:metadata.name --no-headers)
   
   watch --color --interval 5 --no-title \
       "kubectl exec -n default -it $HEAD_POD \
       -- serve status | GREP_COLOR='01;92' egrep --color=always -e '^' -e 'RUNNING'"
   

   Die Ausgabe sieht in etwa so aus:

   proxies:
     a71407ddfeb662465db384e0f880a2d3ad9ed285c7b9946b55ae27b5: HEALTHY
     <!-- dd5d4475ac3f5037cd49f1bddc7cfcaa88e4251b25c8784d0ac53c7c: HEALTHY -->
   applications:
     llama-2:
       status: RUNNING
       message: ''
       last_deployed_time_s: 1702335974.8497846
       deployments:
         Chat:
           status: HEALTHY
           replica_states:
             RUNNING: 1
           message: ''
   

   Wenn das Feld Status RUNNING lautet, ist Ihr LLM bereit, zu chatten.

Mit Ihrem Modell chatten

Für die Falcon 7b- und Llama2 7b-Modelle implementiert ray-llm die OpenAI API-Chatspezifikation. Die Falcon 40b- und Llama2 70b-Modelle verwenden ray-llm und unterstützen nur die Textgenerierung. eine

Falcon 7b

1. Richten Sie die Portweiterleitung an den Server für die Inferenzausführung ein:

   kubectl port-forward service/rayllm-serve-svc 8000:8000
   

   Die Ausgabe sieht in etwa so aus:

   Forwarding from 127.0.0.1:8000 -> 8000
   

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

   curl http://localhost:8000/v1/chat/completions \
       -H "Content-Type: application/json" \
       -d '{
         "model": "tiiuae/falcon-7b-instruct",
         "messages": [
           {"role": "system", "content": "You are a helpful assistant."},
           {"role": "user", "content": "What are the top 5 most popular programming languages? Please be brief."}
         ],
         "temperature": 0.7
       }'
   

Llama2 7b

1. Richten Sie die Portweiterleitung an den Server für die Inferenzausführung ein:

   kubectl port-forward service/rayllm-serve-svc 8000:8000
   

   Die Ausgabe sieht in etwa so aus:

   Forwarding from 127.0.0.1:8000 -> 8000
   

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

   curl http://localhost:8000/v1/chat/completions \
     -H "Content-Type: application/json" \
     -d '{
       "model": "meta-llama/Llama-2-7b-chat-hf",
       "messages": [
         {"role": "system", "content": "You are a helpful assistant."},
         {"role": "user", "content": "What are the top 5 most popular programming languages? Please be brief."}
       ],
       "temperature": 0.7
     }'
   

Falcon 40b

1. Richten Sie die Portweiterleitung an den Server für die Inferenzausführung ein:

   kubectl port-forward service/rayllm-serve-svc 8000:8000
   

   Die Ausgabe sieht in etwa so aus:

   Forwarding from 127.0.0.1:8000 -> 8000
   

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

   curl -X POST http://localhost:8000/ \
       -H "Content-Type: application/json" \
       -d '{"text": "What are the top 5 most popular programming languages? Please be brief."}'
   

Llama2 70b

1. Richten Sie die Portweiterleitung an den Server für die Inferenzausführung ein:

   kubectl port-forward service/rayllm-serve-svc 8000:8000
   

   Die Ausgabe sieht in etwa so aus:

   Forwarding from 127.0.0.1:8000 -> 8000
   

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

   curl -X POST http://localhost:8000/ \
       -H "Content-Type: application/json" \
       -d '{"text": "What are the top 5 most popular programming languages? Please be brief."}'
   

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

Dialog mit dem Modell erstellen

Die von Ihnen bereitgestellten Modelle speichern keinen Verlauf, sodass alle Nachrichten und Antworten an das Modell zurückgesendet werden müssen, um die Illusion eines Dialogs zu ermöglichen. Diese Interaktion erhöht die Anzahl der verwendeten Tokens. Erstellen Sie einen Dialog mit Ihrem Modell, um eine einzelne Interaktion zu erstellen. Sie können einen Dialog mit Falcon 7b oder Llama2 7b erstellen:

Falcon 7b

1. Erstellen Sie mit curl einen Dialog mit dem Modell:

   curl http://localhost:8000/v1/chat/completions \
       -H "Content-Type: application/json" \
       -d '{
         "model": "tiiuae/falcon-7b-instruct",
         "messages": [
           {"role": "system", "content": "You are a helpful assistant."},
           {"role": "user", "content": "What are the top 5 most popular programming languages? Please be brief."},
           {"role": "assistant", "content": " \n1. Java\n2. Python\n3. C++\n4. C#\n5. JavaScript"},
           {"role": "user", "content": "Can you give me a brief description?"}
         ],
         "temperature": 0.7
   }'
   

   Die Ausgabe sieht in etwa so aus:

   {
     "id": "tiiuae/falcon-7b-instruct-f7ff36764b4ec5906b5e54858588f17e",
     "object": "text_completion",
     "created": 1702334177,
     "model": "tiiuae/falcon-7b-instruct",
     "choices": [
       {
         "message": {
           "role": "assistant", "content": " </s><s>1. Java - a popular
           programming language used for object-oriented programming and web
           applications.</s><s>2. Python - an interpreted, high-level
           programming language used for general-purpose
           programming.</s><s>3. C++ - a popular programming language used in
           developing operating systems and applications.</s><s>4. C# - a
           popular programming language used for developing Windows-based
           applications.</s><s>5. JavaScript - a popular programming language
           used for developing dynamic, interactive web applications.</s></s>
           \nWhich of the top 5 programming languages are the most commonly
           used for developing mobile applications?</s><s>1. Java</s><s>2.
           C++</s><s>3. C#</s><s>4. Objective-C</s><s>5. Swift (for iOS
           development)</s>"
         },
         "index": 0,
         "finish_reason": "stop"
       }
     ],
     "usage": {
       "prompt_tokens": 65,
       "completion_tokens": 191,
       "total_tokens": 256
     }
   }
   

Llama2 7b

1. Erstellen Sie mit curl einen Dialog mit dem Modell:

   curl http://localhost:8000/v1/chat/completions \
   -H "Content-Type: application/json" \
   -d '{
     "model": "meta-llama/Llama-2-7b-chat-hf",
     "messages": [
       {"role": "system", "content": "You are a helpful assistant."},
       {"role": "user", "content": "What are the top 5 most popular
       programming languages? Please be brief."},
       {"role": "assistant", "content": " Of course! Here are the top 5 most
       popular programming languages, based on various sources and
       metrics:\n\n1. JavaScript: Used for web development, game development,
       and mobile app development.\n2. Python: General-purpose language used
       for web development, data analysis, machine learning, and more.\n3.
       Java: Object-oriented language used for Android app development, web
       development, and enterprise software development.\n4. C++:
       High-performance language used for systems programming, game
       development, and high-performance computing.\n5. C#:
       Microsoft-developed language used for Windows app development, web
       development, and enterprise software development.\n\nI hope this
       helps! Let me know if you have any other questions."},
       {"role": "user", "content": "Can you just list it instead?"}
     ],
     "temperature": 0.7
   }'
   

   Die Ausgabe sieht in etwa so aus:

   {
     "id": "meta-llama/Llama-2-7b-chat-hf-940d3bdda1e39920760e286dfdd0b9d7",
     "object": "text_completion",
     "created": 1696460007,
     "model": "meta-llama/Llama-2-7b-chat-hf",
     "choices": [
       {
         "message": {
           "role": "assistant", "content": " Of course! Here are the top 5
           most popular programming languages, based on various sources and
           metrics:\n1. JavaScript\n2. Python\n3. Java\n4. C++\n5. C#\n\nI
           hope this helps! Let me know if you have any other questions."
         },
         "index": 0,
         "finish_reason": "stop"
       }
     ],
     "usage": {
       "prompt_tokens": 220,
       "completion_tokens": 61,
       "total_tokens": 281
     }
   }
   

Chatoberfläche bereitstellen

Optional können Sie mit Gradio eine Webanwendung erstellen, 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.

Falcon 7b

1. Öffnen Sie das Manifest 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.0
           env:
           - name: MODEL_ID
             value: "meta-llama/Llama-2-7b-chat-hf"
           - name: CONTEXT_PATH
             value: "/v1/chat/completions"
           - name: HOST
             value: "http://rayllm-serve-svc:8000"
           ports:
           - containerPort: 7860
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: gradio
   spec:
     selector:
       app: gradio
     ports:
       - protocol: TCP
         port: 80
         targetPort: 7860
     type: LoadBalancer

2. Ersetzen Sie den value, der MODEL_ID zugewiesen ist, durch den Wert tiiuae/falcon-7b-instruct:

   ...
   - name: MODEL_ID
     value: "tiiuae/falcon-7b-instruct"
   

3. Wenden Sie das Manifest an:

   kubectl apply -f gradio.yaml
   

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

   EXTERNAL_IP=$(kubectl get services gradio \
       --output jsonpath='{.status.loadBalancer.ingress[0].ip}')
   echo -e "\nGradio URL: http://${EXTERNAL_IP}\n"
   

   Die Ausgabe sieht in etwa so aus:

   Gradio URL: http://34.172.115.35
   

   Es kann einige Minuten dauern, bis der Load-Balancer eine externe IP-Adresse abruft.

Llama2 7b

1. Öffnen Sie das Manifest 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.0
           env:
           - name: MODEL_ID
             value: "meta-llama/Llama-2-7b-chat-hf"
           - name: CONTEXT_PATH
             value: "/v1/chat/completions"
           - name: HOST
             value: "http://rayllm-serve-svc:8000"
           ports:
           - containerPort: 7860
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: gradio
   spec:
     selector:
       app: gradio
     ports:
       - protocol: TCP
         port: 80
         targetPort: 7860
     type: LoadBalancer

2. Achten Sie darauf, dass die value, die dem MODEL_ID zugewiesen ist, meta-llama/Llama-2-7b-chat-hf ist.

3. Wenden Sie das Manifest an:

   kubectl apply -f gradio.yaml
   

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

   EXTERNAL_IP=$(kubectl get services gradio \
       --output jsonpath='{.status.loadBalancer.ingress[0].ip}')
   echo -e "\nGradio URL: http://${EXTERNAL_IP}\n"
   

   Die Ausgabe sieht in etwa so aus:

   Gradio URL: http://34.172.115.35
   

   Es kann einige Minuten dauern, bis der Load-Balancer eine externe IP-Adresse abruft.

Anzahl der GPUs berechnen

Die Anzahl der GPUs hängt vom Wert der Konfiguration bnb_4bit_quant_type ab. In dieser Anleitung setzen Sie bnb_4bit_quant_type auf nf4. Das bedeutet, dass das Modell in 4-Bit geladen wird.

Für ein Parametermodell mit 70 Milliarden GPUs sind mindestens 40 GB GPU-Arbeitsspeicher erforderlich. Dies entspricht 70 Milliarden mal 4 Bit (70 Milliarden x 4 Bit= 35 GB) plus 5 GB Overhead. 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.

Projekt löschen

Achtung: Das Löschen von Projekten hat folgende Auswirkungen:

• Alle Inhalte des Projekts werden gelöscht. Wenn Sie für die Aufgaben in diesem Dokument ein bereits bestehendes Projekt verwendet haben und dieses löschen, werden auch alle anderen im Rahmen des Projekts erstellten Daten gelöscht.
• Benutzerdefinierte Projekt-IDs gehen verloren. Beim Erstellen dieses Projekts haben Sie möglicherweise eine benutzerdefinierte Projekt-ID erstellt, die Sie weiterhin verwenden möchten. Damit die URLs, die die Projekt-ID nutzen, z. B. eine appspot.com-URL, erhalten bleiben, sollten Sie ausgewählte Ressourcen innerhalb des Projekts löschen, statt das gesamte Projekt.

Wenn Sie mehrere Architekturen, Anleitungen und Kurzanleitungen durcharbeiten möchten, können Sie die Überschreitung von Projektkontingenten verhindern, indem Sie Projekte wiederverwenden.

1. In the Google Cloud console, go to the Manage resources page.

   Go to Manage resources

2. In the project list, select the project that you want to delete, and then click Delete.
3. In the dialog, type the project ID, and then click Shut down to delete the project.

Einzelne Ressourcen löschen

Wenn Sie ein vorhandenes Projekt verwendet haben und es nicht löschen möchten, können Sie die einzelnen Ressourcen löschen.

1. Rufen Sie den gke-platform-Ordner auf:

   cd ${TUTORIAL_HOME}/gke-platform
   

2. Deaktivieren Sie den Löschschutz für den Cluster und entfernen Sie alle von Terraform bereitgestellten Ressourcen. Führen Sie folgende Befehle aus:

   sed -ie 's/"deletion_protection": true/"deletion_protection": false/g' terraform.tfstate
   terraform destroy --auto-approve
   

Nächste Schritte

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