Einführung: Warum sich TensorRT-LLM für Ihr Wochenende lohnt. Wenn Sie jemals erlebt haben, dass eine GPU bei 60 % Auslastung arbeitet, während Ihr LLM langsam ist, wissen Sie, dass noch freie Leistung vorhanden ist. TensorRT-LLM wandelt diesen Spielraum in Durchsatz um: Fused Kernels, Paged Attention, Quantisierung und Optimierungen auf Grafikebene, die die Latenz senken und die Tokens pro Sekunde erhöhen. In dieser Anleitung führen wir Sie von der Installation über den Engine-Build bis hin zum Serving, damit Sie schnelleres, kostengünstigeres Inference auf NVIDIA-GPUs bereitstellen können.
Dieses Tutorial ist praxisorientiert und lösungsorientiert geschrieben. Wir verwenden eine fragengesteuerte Struktur mit kopierbaren Befehlen, häufigen Fallstricken und Entscheidungspunkten für FP16 vs. INT8, Batching und KV-Cache-Strategien. Wir verweisen auch auf offizielle Ressourcen für tiefergehende Informationen, wo dies angebracht ist.
Was Sie lernen werden
- Wie Sie die Umgebung für TensorRT-LLM einrichten
- Wie Sie ein Modell (von Hugging Face oder Checkpoints) für den Engine-Build vorbereiten
- Wie Sie FP16/INT8-Engines bauen und die Leistung optimieren
- Wie Sie Inference über Python/C++ und HTTP-Serving ausführen
- Wie Sie Benchmarking, Batching und Debugging durchführen
Für wen ist dies geeignet
- ML-Ingenieure, die LLMs auf NVIDIA-GPUs bereitstellen
- Praktiker, die Kosten/Latenz in der Produktion optimieren
- Entwickler, die von PyTorch Transformers zu hochoptimiertem Inference übergehen
- Was ist TensorRT-LLM und wann sollten Sie es verwenden? TensorRT-LLM ist ein Inference-Stack, der Transformer-Modelle in hochoptimierte GPU-„Engines“ kompiliert. Im Vergleich zu rohem PyTorch oder generischen Runtimes erhalten Sie typischerweise:
- Geringere Latenz pro Token
- Höheren Durchsatz bei großen Batch-Größen
- Bessere Speichereffizienz mit Paged KV-Cache und Quantisierung. Verwenden Sie es, wenn Sie auf NVIDIA-GPUs laufen und Wert auf produktionsreife Leistung legen. Es ist besonders wertvoll für Decoder-Only-LLMs (z. B. Llama, Mistral, Phi, BLOOM) und Szenarien wie Chatbots, RAG und High-QPS-API-Dienste.
- Voraussetzungen und Umgebungseinrichtung. Kernanforderungen
- NVIDIA GPU mit aktueller Compute Capability (z. B. Ampere, Ada, Hopper)
- Passende CUDA- und TensorRT-Versionen sowie entsprechende Treiber
- Python 3.8+ und Build-Tools, wenn aus der Quelle kompiliert wird
Versionshinweis: Überprüfen Sie vor der Installation immer die offizielle TensorRT-Supportmatrix und die Versionshinweise auf kompatible CUDA/TensorRT-Versionen und -Funktionen.
Schnellstart-Optionen
- Containerisiert: Verwenden Sie die Container von NVIDIA mit vorinstalliertem CUDA/TensorRT – der schnellste Weg, um Versionskonflikte zu vermeiden.
- Native Installation: Befolgen Sie den offiziellen Schnellstart für das Basis-TensorRT und legen Sie dann TensorRT-LLM darüber.
- Vorbereitung Ihres Modells (Hugging Face → TensorRT-LLM). Häufige Quellen
- Hugging Face: Llama/Mistral/BLOOM-Varianten
- Lokale Checkpoints: Benutzerdefinierte Feinabstimmungen
Checkliste zur Vorbereitung
- Bestätigen Sie, dass die Modellarchitektur von TensorRT-LLM unterstützt wird.
- Laden Sie Modellgewichte und Tokenizer herunter.
- Konvertieren Sie bei Bedarf Safetensors in die erwarteten Formate oder exportieren Sie sie über die Skripte des Projekts nach ONNX.
Tipp: Der offizielle Schnellstart enthält oft Skripte zum Abrufen von Modellen und zum Konvertieren in die richtige Zwischenform. Für eine schrittweise Anleitung mit einem BLOOM-Beispiel siehe Dells Leitfaden zum Konvertieren von Hugging Face LLMs in TensorRT-LLM.
- Erstellen einer TensorRT-LLM-Engine (das Herzstück des Workflows). Konzepte, die Sie kennen sollten
- Engine: Das kompilierte, hardwareoptimierte Artefakt, das Sie für Inference laden.
- Präzision: FP16/BF16 für eine starke Baseline; INT8 oder FP8 für höheren Durchsatz, wenn die Genauigkeit erhalten bleibt.
- KV-Cache: Paged KV-Cache reduziert die Speicherfragmentierung und steigert die Leistung bei langen Kontexten.
Überblick über die Schritte
- Definieren Sie die Build-Konfiguration: maximale Batch-, Sequenzlängen, Präzision, Quantisierung und GPU-Architektur.
- Verweisen Sie auf Ihre Modell-Checkpoints und den Tokenizer.
- Kompilieren Sie die Engine für Ihre Ziel-GPU(s).
Referenz: Erstellen von Engines mit offiziellen Dokumenten und Konfigurationen. Wenn Sie über Hugging Face Text Generation Inference (TGI) bereitstellen möchten, lesen Sie die TRT-LLM-Backend-Hinweise zur Vorkompilierung von Engines pro GPU-Architektur und -Konfiguration.
Entscheidungsbaum für den Einstieg
- Erster Build: FP16, mittlere maximale Sequenzlänge (z. B. 4K–8K), moderater Batch (z. B. 4–8). Validieren Sie die Korrektheit.
- Hochskalieren: Aktivieren Sie den Paged KV-Cache. Erhöhen Sie die maximale Batch-/Beam-Größe. Experimentieren Sie mit FP8 oder INT8.
- Produktion: Fixieren Sie Konfigurationen, die die Latenz-/QPS-SLOs erfüllen; erstellen Sie separate Engines für jedes Szenario (kurze Prompts vs. lange Kontexte).
- Ausführen von Inference: Python, C++ und HTTP. Sie haben drei gängige Wege:
- Python: Schnelle Prototypenerstellung, ideal für Pipelines und Notebooks.
- C++: Maximale Leistung, Integration in native Dienste.
- HTTP Serving: Verwenden Sie TGI mit dem TRT-LLM-Backend oder die Serving-Beispiele der Runtime für eine skalierbare Bereitstellung.
Hugging Face TGI Backend
- Vorkompilieren Sie Engines für Ihr exaktes GPU-/Präzisions-Setup.
- Starten Sie TGI mit dem TRT-LLM-Backend und verweisen Sie auf das Engine-Verzeichnis.
- Senden Sie Anfragen über /generate oder openai-kompatible Routen und skalieren Sie mit Replicas.
- Performance-Tuning, das wirklich etwas bewegt. Wo Sie anfangen sollten
- Präzision: FP16 ist Ihre zuverlässige Baseline. INT8/FP8 können die Latenz weiter reduzieren, aber validieren Sie die Qualität.
- Batching: Dynamisches Batching und Request Coalescing erhöhen den Durchsatz dramatisch; messen Sie die Tail-Latenz.
- Paged KV Cache: Essentiell für lange Prompts und Streaming; reduziert den Speicherdruck.
- Maximale Längen: Größere maximale Sequenzlängen erhöhen die Engine-Größe und können die Taktrate reduzieren; bauen Sie zweckmäßige Engines.
Praktische Tipps
- Benchmark mit realistischen Prompts: Messen Sie die Prefill- vs. Decode-Phasen separat.
- Der Tokenizer-Durchsatz ist wichtig: Führen Sie ihn auf der GPU aus, wenn Ihr Framework dies unterstützt.
- Behalten Sie CUDA-Graphen/Fused Kernels im Auge: Sie reduzieren den CPU-Overhead und die Kernel-Startlatenz.
- Für Multi-GPU: Bevorzugen Sie Tensor Parallel oder Pipeline Parallel entsprechend Ihrer Modellgröße und Ihren Latenzanforderungen.
- Benchmarking: Beweisen Sie den Gewinn. Checkliste
- Tokens/Sek. (Durchsatz) bei Ziel-Batchgrößen
- Time-to-first-token (TTFT) und End-to-End-Latenz pro Anfrage
- GPU-Auslastung und Speicherplatz unter maximaler QPS
- Genauigkeit: BLEU/Perplexity oder aufgabenspezifische Evaluierungen, wenn Sie quantisieren
Verwenden Sie konsistente Seeds und Prompt-Sets über Baselines hinweg (PyTorch vs. TensorRT-LLM), um die Korrektheit und Deltas zu validieren.
- Debugging und häufige Fallstricke
- Nicht übereinstimmende Versionen: Richten Sie CUDA-, Treiber- und TensorRT-Versionen gemäß der offiziellen Supportmatrix aus.
- Engine ungültig für Gerät: Erstellen Sie Engines speziell für Ihre GPU-Architektur neu.
- OOM während des Builds: Reduzieren Sie die maximale Sequenzlänge oder den Batch; aktivieren Sie Paged KV; erwägen Sie die Quantisierung.
- Genauigkeitsverlust mit INT8: Kalibrieren Sie mit domänenrepräsentativen Daten; versuchen Sie die Per-Tensor-Quantisierung und überprüfen Sie die Layer-weise Empfindlichkeit.
- Langsame TTFT trotz hohem Durchsatz: Optimieren Sie den Paged KV-Cache, aktivieren Sie CUDA-Graphen und prüfen Sie auf Tokenizer-Engpässe.
- Beispiel-Workflow: Vom Hugging Face-Modell zur Produktion. Szenario: Sie möchten ein Chatmodell mit niedriger Latenz auf einem A100.
- Modell auswählen: 7B–13B Llama/Mistral-Variante.
- Vorbereiten: Laden Sie Gewichte und Tokenizer herunter; überprüfen Sie, ob die Architektur unterstützt wird.
- Erste Engine: FP16, maximaler Input 4K, maximaler Output 1K, Batch 4; Paged KV ein.
- Validieren: Vergleichen Sie die Ausgaben mit Ihrer PyTorch-Baseline.
- Optimieren: Probieren Sie INT8 oder FP8 aus; messen Sie TTFT und Durchsatz. Erhöhen Sie den Batch für den Servermodus.
- Bereitstellen: Verwenden Sie das TGI TRT-LLM-Backend; skalieren Sie Replicas hinter einem Load Balancer; fügen Sie Streaming hinzu.
- Kosten- und Kapazitätsplanung
- Durchsatz pro GPU: Messen Sie Tokens/Sek. bei Ihrem Zielkontext. Verwenden Sie dies, um die QPS-Kapazität zu berechnen.
- Preis pro 1 Million Tokens: Mit schnellerer Dekodierung und höherer Batch-Auslastung senkt TRT-LLM in der Regel die Kosten pro Token.
- Engines richtig dimensionieren: Erstellen Sie separate Engines für Kurz- und Langformate, um die Headroom-Verschwendung zu minimieren.
- FAQs im Leitfaden. F: Muss ich Engines für jeden GPU-Typ neu erstellen? A: Ja. Engines sind hardwarespezifisch. Erstellen Sie sie für jede GPU-Architektur, auf der Sie sie bereitstellen werden.
F: Wie stark beeinflusst INT8 die Qualität? A: Das hängt vom Modell und der Aufgabe ab. Mit guten Kalibrierungsdaten behalten viele Modelle eine nahezu FP16-Qualität bei und bieten gleichzeitig erhebliche Beschleunigungen.
F: Kann ich lange Kontexte (z. B. 32K) ausführen? A: Ja, aber planen Sie den Speicher sorgfältig. Verwenden Sie den Paged KV-Cache und optimieren Sie die Blockgrößen; beachten Sie, dass längere Kontexte den Engine-Footprint und die Dekodierungskosten erhöhen.
F: Ist TGI erforderlich? A: Nein. Sie können Python/C++ direkt ausführen. TGI ist praktisch für produktionsreife HTTP-APIs mit Autoscaling und Logging.
Wichtig für die Workflow-Beschleunigung. Wenn Sie häufig Prompts iterieren, Ausgaben über verschiedene Engines vergleichen oder Experimente dokumentieren, kann ein Side-by-Side-KI-Assistent, der schnelle Wiederholungen, Codeblockausführung und Web-Snippets unterstützt, Ihre Schleife beschleunigen. Übrigens bietet Sider.AI eine Desktop-Erfahrung, die auf Ingenieure zugeschnitten ist – praktisch für die Erfassung von Benchmarks, das Testen von Prompts und die Organisation Ihrer Notizen, während Sie Ihre TensorRT-LLM-Pipeline optimieren. Checkliste für die nächsten Schritte
- Lesen Sie den offiziellen Schnellstart, um Ihre Umgebung zu validieren.
- Bestätigen Sie die CUDA/TensorRT-Kompatibilität in der Supportmatrix.
- Folgen Sie dem Engine-Build-Leitfaden und wählen Sie zuerst FP16.
- Wenn Sie über TGI bereitstellen, vorkompilieren Sie Engines und konfigurieren Sie das TRT-LLM-Backend.
- Optional können Sie eine schrittweise Anleitung für Hugging Face-Modelle wie BLOOM durchgehen.
Wichtige Erkenntnisse
- TensorRT-LLM kompiliert Ihren Transformer in eine GPU-native Engine für maximalen Durchsatz und geringere Latenz.
- Beginnen Sie mit FP16, aktivieren Sie den Paged KV-Cache und messen Sie. Erkunden Sie dann INT8/FP8 für mehr Geschwindigkeit.
- Engines sind GPU- und konfigurationsspezifisch; erstellen Sie sie pro Bereitstellungsziel.
- Kombinieren Sie für die Produktion Engines mit einer robusten Serving-Schicht (z. B. TGI) und überwachen Sie TTFT, Durchsatz und Qualität.
FAQ
F1: Wie installiere und richte ich TensorRT-LLM richtig ein? Verwenden Sie einen Container mit passendem CUDA/TensorRT oder befolgen Sie den offiziellen Schnellstart und die Supportmatrix, um Versionsabweichungen zu vermeiden. Überprüfen Sie die GPU-Treiber und Build-Tools, bevor Sie Engines kompilieren.
F2: Wie verwende ich TensorRT-LLM mit Hugging Face-Modellen? Laden Sie das Modell und den Tokenizer herunter, bestätigen Sie die Unterstützung und konvertieren Sie sie bei Bedarf, bevor Sie die Engine erstellen. Wenn Sie mit TGI bereitstellen, kompilieren Sie Engines für Ihre GPU und verweisen Sie das Backend auf das Engine-Verzeichnis.
F3: Sollte ich FP16, FP8 oder INT8 für TensorRT-LLM wählen? Beginnen Sie mit FP16 für Stabilität und versuchen Sie dann FP8/INT8, um den Durchsatz zu erhöhen. Validieren Sie immer die Aufgabenpräzision nach der Quantisierung.
F4: Kann ich TensorRT-LLM über HTTP bereitstellen? Ja. Sie können Python/C++ direkt verwenden oder über das TRT-LLM-Backend von Hugging Face TGI für skalierbare, produktionsreife APIs mit Streaming bereitstellen.
F5: Was sind häufige Performance-Engpässe bei der Verwendung von TensorRT-LLM? Tokenizer-Overhead, suboptimales Batching und fehlender Paged KV-Cache sind häufige Probleme. Optimieren Sie die Batchgrößen, aktivieren Sie CUDA-Graphen und überwachen Sie TTFT im Vergleich zu den gesamten Tokens pro Sekunde.
