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. Wechseln Sie in der Google Cloud Console zur Seite Ressourcen verwalten.

    Zur Seite „Ressourcen verwalten“

  2. Wählen Sie in der Projektliste das Projekt aus, das Sie löschen möchten, und klicken Sie dann auf Löschen.
  3. Geben Sie im Dialogfeld die Projekt-ID ein und klicken Sie auf Shut down (Beenden), um das Projekt zu löschen.

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