Best Practices für die Optimierung der Inferenz von Large Language Models mit GPUs in der Google Kubernetes Engine (GKE)

Google Kubernetes Engine (GKE) bietet eine detaillierte Kontrolle für die Inferenz von Large Language Models (LLM) bei optimaler Leistung und Kosten. In diesem Leitfaden werden Best Practices für die Optimierung der Inferenz und Bereitstellung von offenen LLMs mit GPUs in GKE mithilfe der vLLM und Text Generation Inference (TGI) Bereitstellungs-Frameworks beschrieben.

Eine zusammenfassende Checkliste mit den Best Practices finden Sie in der Zusammenfassung der Checkliste.

Ziele

Dieser Leitfaden richtet sich an Kunden von generativer KI, neue oder bestehende GKE-Nutzer, ML-Entwickler und LLMOps-Entwickler (DevOps), die ihre LLM-Arbeitslasten mit GPUs und Kubernetes optimieren möchten.

Nach Abschluss dieses Leitfadens können Sie:

• Techniken zur LLM-Optimierung nach dem Training auswählen, einschließlich Quantisierung, Tensor-Parallelität und Arbeitsspeicheroptimierung.
• Die allgemeinen Vor- und Nachteile bei der Auswahl dieser Optimierungstechniken abwägen.
• Offene LLM-Modelle in GKE mit Bereitstellungs-Frameworks wie vLLM oder TGI mit aktivierten Optimierungseinstellungen bereitstellen.

Übersicht über Techniken zur Optimierung der LLM-Bereitstellung

Im Gegensatz zu Nicht-KI-Arbeitslasten weisen LLM-Arbeitslasten aufgrund ihrer Abhängigkeit von Matrixmultiplikationsvorgängen in der Regel eine höhere Latenz und einen geringeren Durchsatz auf. Um die LLM-Inferenzleistung zu verbessern, können Sie spezielle Hardwarebeschleuniger (z. B. GPUs und TPUs) und optimierte Bereitstellungs-Frameworks verwenden.

Sie können eine oder mehrere der folgenden Best Practices anwenden, um die Latenz von LLM-Arbeitslasten zu reduzieren und gleichzeitig den Durchsatz und die Kosteneffizienz zu verbessern:

• Quantisierung
• Tensor-Parallelität
• Optimierung des Modellspeichers

In den Beispielen in diesem Leitfaden wird das Gemma 7B-LLM zusammen mit den Bereitstellungs-Frameworks vLLM oder TGI verwendet, um diese Best Practices anzuwenden. Die beschriebenen Konzepte und Funktionen gelten jedoch für die meisten gängigen offenen LLMs.

Hinweise

Bevor Sie die Beispiele in diesem Leitfaden ausprobieren, führen Sie die folgenden erforderlichen Aufgaben aus:

1. Folgen Sie der Anleitung in diesen Leitfäden, um auf das Gemma Modell zuzugreifen, Ihre Umgebung vorzubereiten und Ressourcen zu erstellen und zu konfigurieren Cloud de Confiance by S3NS :

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

   Speichern Sie das Hugging Face-Zugriffstoken in Ihrem Kubernetes-Secret.

2. Klonen Sie das Beispiel-Repository https://github.com/GoogleCloudPlatform/kubernetes-engine-samples/ in Ihre lokale Entwicklungsumgebung.

3. Ändern Sie Ihr Arbeitsverzeichnis in /kubernetes-engine-samples/ai-ml/llm-serving-gemma/:

Best Practice: Quantisierung

Die Quantisierung ist eine Technik, die der verlustbehafteten Bildkomprimierung ähnelt. Sie reduziert die Modellgröße, indem Gewichte in Formaten mit geringerer Genauigkeit (8 Bit oder 4 Bit) dargestellt werden, wodurch die Arbeitsspeicheranforderungen sinken. Wie bei der Bildkomprimierung ist die Quantisierung jedoch ein Kompromiss: Eine geringere Modellgröße kann zu einer geringeren Genauigkeit führen.

Es gibt verschiedene Quantisierungsmethoden, die jeweils eigene Vor- und Nachteile haben. Einige wie AWQ und GPTQ erfordern eine Vorquantisierung und sind auf Plattformen wie Hugging Face oder Kaggle verfügbar. Wenn Sie beispielsweise GPTQ auf das Llama-2 13B-Modell und AWQ auf das Gemma 7B-Modell anwenden, können Sie die Modelle auf einer einzelnen L4-GPU anstelle von zwei L4-GPUs ohne Quantisierung bereitstellen.

Sie können die Quantisierung auch mit Tools wie AutoAWQ und AutoGPTQ durchführen. Diese Methoden können die Latenz und den Durchsatz verbessern. Im Gegensatz dazu erfordern Techniken mit EETQ und der Bibliothek bitsandbytes für die Quantisierung keine vorab quantisierten Modelle. Daher können sie eine geeignete Wahl sein, wenn keine vorab quantisierten Versionen verfügbar sind.

Die beste Quantisierungstechnik hängt von Ihren spezifischen Zielen und der Kompatibilität der Technik mit dem Bereitstellungs-Framework ab, das Sie verwenden möchten. Weitere Informationen finden Sie im Leitfaden zur Quantisierung von Hugging Face.

Wählen Sie einen dieser Tabs aus, um ein Beispiel für die Anwendung der Quantisierung mit den Frameworks TGI oder vLLM zu sehen:

args:
- --model-id=$(MODEL_ID)
- --num-shard=2
- --quantize=bitsandbytes

kubectl apply -f tgi/tgi-7b-bitsandbytes.yaml

args:
- --model=$(MODEL_ID)
- --tensor-parallel-size=1
- --quantization=awq
env:
- name: MODEL_ID
  value: google/gemma-7b-AWQ
resources:
  requests:
    nvidia.com/gpu: 1
  limits:
    nvidia.com/gpu: 1

kubectl apply -f vllm/vllm-7b-awq.yaml

args:
- --model=$(MODEL_ID)
- --tensor-parallel-size=1
- --kv-cache-dtype=fp8_e5m2
- --max-model-len=1200
resources:
  requests:
    cpu: "2"
    memory: "25Gi"
    ephemeral-storage: "25Gi"
    nvidia.com/gpu: 1
  limits:
    cpu: "2"
    memory: "25Gi"
    ephemeral-storage: "25Gi"
    nvidia.com/gpu: 1

kubectl apply -f vllm/vllm-7b-kvcache.yaml

Best Practice: Tensor-Parallelität

Tensor-Parallelität ist eine Technik, die die Rechenlast auf mehrere GPUs verteilt. Dies ist wichtig, wenn Sie große Modelle ausführen, die die Arbeitsspeicherkapazität einer einzelnen GPU überschreiten. Dieser Ansatz kann kostengünstiger sein, da Sie mehrere erschwingliche GPUs anstelle einer einzelnen teuren GPU verwenden können. Außerdem kann der Durchsatz der Modellinferenz verbessert werden. Die Tensor-Parallelität nutzt die Tatsache, dass Tensorvorgänge unabhängig voneinander auf kleineren Datenblöcken ausgeführt werden können.

Weitere Informationen zu dieser Technik finden Sie im Leitfaden zur Tensor-Parallelität von Hugging Face.

Wählen Sie einen dieser Tabs aus, um ein Beispiel für die Anwendung der Tensor-Parallelität mit den Frameworks TGI oder vLLM zu sehen:

args:
- --model-id=$(MODEL_ID)
- --num-shard=2

kubectl apply -f tgi/tgi-7b-it-tensorparallelism.yaml

args:
- --model=$(MODEL_ID)
- --tensor-parallel-size=2

kubectl apply -f vllm/vllm-7b-it-tensorparallelism.yaml

Best Practice: Optimierung des Modellspeichers

Die Optimierung der Arbeitsspeichernutzung von LLMs ist entscheidend für eine effiziente Inferenz. In diesem Abschnitt werden Optimierungsstrategien für die Aufmerksamkeitsebene vorgestellt, z. B. Paged Attention und Flash Attention. Diese Strategien verbessern die Arbeitsspeichereffizienz und ermöglichen längere Eingabesequenzen und eine reduzierte GPU-Leerlaufzeit. In diesem Abschnitt wird auch beschrieben, wie Sie die Größe der Modellein- und ‑ausgabe an die Arbeitsspeicherbeschränkungen anpassen und für bestimmte Bereitstellungsframeworks optimieren können.

Optimierung der Aufmerksamkeitsebene

Self-attention-Schichten ermöglichen es Modellen, den Kontext bei der Sprachverarbeitung zu verstehen, da sich die Bedeutung von Wörtern je nach Kontext ändern kann. Diese Schichten speichern jedoch Eingabetoken-Gewichte, Schlüssel (K) und Werte (V) im GPU-vRAM. Wenn die Eingabesequenz länger wird, führt dies zu einem quadratischen Wachstum der Größe und der Berechnungszeit.

Die Verwendung von KV-Caching ist besonders nützlich bei langen Eingabesequenzen, bei denen der Overhead der Self-Attention erheblich sein kann. Dieser Optimierungsansatz reduziert die Rechenverarbeitung auf eine lineare Komplexität.

Zu den spezifischen Techniken zur Optimierung von Aufmerksamkeitsmechanismen in LLMs gehören:

• Paged Attention: Paged Attention verbessert die Speicherverwaltung für große Modelle und lange Eingabesequenzen durch Auslagerungstechniken, ähnlich dem virtuellen Arbeitsspeicher des Betriebssystems. Dadurch werden Fragmentierung und Duplizierung im KV-Cache effektiv reduziert, was längere Eingabesequenzen ermöglicht, ohne dass der GPU-Arbeitsspeicher aufgebraucht wird.
• Flash Attention: Flash Attention verringert GPU-Arbeitsspeicherengpässe, indem die Datenübertragungen zwischen GPU-RAM und L1-Cache während der Tokengenerierung minimiert werden. Dadurch wird die Leerlaufzeit für Rechenkerne eliminiert und die Inferenz- und Trainingsleistung für GPUs erheblich verbessert.

Feinabstimmung der Modelleingabe und -ausgabe

Die Arbeitsspeicheranforderungen hängen von der Eingabe- und Ausgabegröße ab. Eine längere Ausgabe und mehr Kontext erfordern mehr Ressourcen, während eine kürzere Ausgabe und weniger Kontext Kosten sparen können, indem eine kleinere, günstigere GPU verwendet wird.

Wählen Sie einen dieser Tabs aus, um ein Beispiel für die Feinabstimmung der Arbeitsspeicheranforderungen der Modelleingabe- und -ausgabe in den TGI- oder vLLM-Frameworks zu sehen:

args:
- --model-id=$(MODEL_ID)
- --num-shard=1
- --max-total-tokens=3072 
- --max-batch-prefill-tokens=512
- --max-input-length=512
env:
- name: MODEL_ID
  value: google/gemma-7b

kubectl apply -f tgi/tgi-7b-token.yaml

args:
- --model=$(MODEL_ID)
- --tensor-parallel-size=1
- --max-model-len=600

kubectl apply -f vllm/vllm-7b-token.yaml

Zusammenfassung der Checkliste

Nächste Schritte

• Eine End-to-End-Anleitung zur Containerkonfiguration finden Sie unter LLM mit mehreren GPUs in GKE bereitstellen.
• Wenn Sie eine cloudverwaltete LLM-Bereitstellungslösung benötigen, stellen Sie Ihr Modell über Vertex AI Model Garden bereit.