LLM auf L4-GPUs mit Ray bereitstellen


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:

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.
  • Wenn Sie das Llama 2-Modell verwenden möchten, benötigen Sie Folgendes:

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

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:

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
    
    • 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."}'
    

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

  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