Detaillierte Einführung in das TensorRT-LLM-Projekt

Projektübersicht

TensorRT-LLM ist eine von NVIDIA entwickelte Open-Source-Bibliothek, die speziell zur Optimierung der Inferenzleistung großer Sprachmodelle (LLM) auf NVIDIA GPUs dient. Sie bietet eine benutzerfreundliche Python-API zur Definition großer Sprachmodelle und unterstützt modernste Optimierungstechniken für eine effiziente Inferenz auf NVIDIA GPUs.

Kernmerkmale

1. Fortschrittliche Optimierungstechniken

TensorRT-LLM bietet eine Vielzahl fortschrittlicher Optimierungsfunktionen, darunter:

• Benutzerdefinierte Aufmerksamkeits-Kernels: Speziell optimierte Implementierungen von Aufmerksamkeitsmechanismen
• Dynamisches Batching (Inflight Batching): Echtzeitverarbeitung von Eingabesequenzen unterschiedlicher Länge
• Seitenbasierter KV-Cache: Effizientes Schlüssel-Wert-Cache-Management
• Spekulatives Dekodieren (Speculative Decoding): Beschleunigung der Generierung durch Vorhersage mehrerer Tokens
• Unterstützung verschiedener Quantisierungsformate: FP8, FP4, INT4 AWQ, INT8 SmoothQuant usw.

2. Detaillierte Quantisierungstechniken

TensorRT-LLM bietet ein branchenführendes, einheitliches Quantisierungs-Toolkit, das die Bereitstellung von Deep Learning/Generativer KI auf NVIDIA-Hardware erheblich beschleunigt, während die Modellgenauigkeit erhalten bleibt.

Wichtige Quantisierungsmethoden:

• FP8: Bietet in der Regel die beste Leistung und Genauigkeit in Szenarien mit großen Batches, geeignet für Batch-Größen ≥16
• INT8 SmoothQuant: Gewichtungsglättung und INT8-Kanalquantisierung, Aktivierungsbereich-Skalierung auf Tensorebene
• INT4 AWQ: Gewichtungs-Reskalierung und Block-Level-Quantisierung auf INT4, empfohlen für Szenarien mit kleinen Batches (Batch-Größe ≤4)
• W4A8 AWQ: Gewichtungsquantisierung auf INT4, Aktivierungsquantisierung auf INT8

Leistungssteigerung:

Laut Benchmarks können Quantisierungstechniken zu einer signifikanten Leistungssteigerung führen:

• FP8-Quantisierung: Im Vergleich zur FP16-Baseline kann das Llama 3 8B-Modell eine 1,45-fache Beschleunigung und das 70B-Modell eine 1,81-fache Beschleunigung erreichen.
• INT4 AWQ: Bei einer Batch-Größe von 1 kann das 70B-Modell eine Leistungssteigerung von bis zu 2,66-fach erzielen.
• Speicheroptimierung: Alle quantisierten Versionen des Llama 3 70B-Modells können auf einer einzelnen NVIDIA H100 GPU ausgeführt werden, während FP16-Genauigkeit mindestens zwei GPUs erfordert.

3. Multi-GPU- und Multi-Node-Unterstützung

TensorRT-LLM umfasst Vor- und Nachbearbeitungsschritte sowie Multi-GPU- und Multi-Node-Kommunikationsprimitive, die durch eine einfache Open-Source-Modelldefinitions-API bahnbrechende LLM-Inferenzleistung ermöglichen.

4. Umfassende Hardware-Unterstützung

TensorRT-LLM unterstützt GPUs basierend auf den NVIDIA Hopper-, NVIDIA Ada Lovelace- und NVIDIA Ampere-Architekturen. Insbesondere:

• H100 GPU: Unterstützt die automatische Konvertierung und optimierte Kernels für das FP8-Format.
• H200 GPU: Kann auf Llama2-13B nahezu 12.000 Tokens/Sekunde erreichen.
• RTX-Serie: Unterstützt die Inferenz großer Modelle auf Consumer-GPUs.

Installation und Nutzung

Docker-Installation (empfohlen)

# Ausführen des vorgefertigten Docker-Containers
docker run --ipc host --gpus all -it nvcr.io/nvidia/tensorrt-llm/release

LLM API-Nutzungsbeispiel

from tensorrt_llm import BuildConfig, SamplingParams
from tensorrt_llm._tensorrt_engine import LLM

def main():
    build_config = BuildConfig()
    build_config.max_batch_size = 256
    build_config.max_num_tokens = 1024
    
    # Unterstützt HuggingFace-Modellnamen, lokale HF-Modellpfade oder TensorRT-Modelloptimierer-Quantisierungs-Checkpoints
    llm = LLM(model="TinyLlama/TinyLlama-1.1B-Chat-v1.0", 
              build_config=build_config)
    
    # Beispiel-Prompts
    prompts = [
        "Hello, my name is",
        "The capital of France is",
        "The future of AI is",
    ]
    
    # Erstellen von Sampling-Parametern
    sampling_params = SamplingParams(temperature=0.8, top_p=0.95)
    
    for output in llm.generate(prompts, sampling_params):
        print(f"Prompt: {output.prompt!r}, Generated text: {output.outputs[0].text!r}")

Online-Dienst-Bereitstellung

# Starten eines OpenAI-kompatiblen Servers
trtllm-serve --model TinyLlama/TinyLlama-1.1B-Chat-v1.0 --port 8000

Quantisierungs-Workflow

Grundlegende Quantisierungsbefehle

# FP8-Quantisierung
python quantize.py --model_dir $MODEL_PATH --qformat fp8 --kv_cache_dtype fp8 --output_dir $OUTPUT_PATH

# INT4 AWQ-Quantisierung
python quantize.py --model_dir $MODEL_PATH --qformat int4_awq --awq_block_size 64 --tp_size 4 --output_dir $OUTPUT_PATH

# INT8 SmoothQuant-Quantisierung
python quantize.py --model_dir $MODEL_PATH --qformat int8_sq --kv_cache_dtype int8 --output_dir $OUTPUT_PATH

# Auto-Quantisierung (Kombination mehrerer Methoden)
python quantize.py --model_dir $MODEL_PATH --autoq_format fp8,int4_awq,w4a8_awq --output_dir $OUTPUT_PATH --auto_quantize_bits 5 --tp_size 2

Unterstützte Modelle

TensorRT-LLM unterstützt eine große Anzahl beliebter LLM-Architekturen, einschließlich, aber nicht beschränkt auf:

• Llama-Serie: Llama 2, Llama 3, Llama 3.1, Llama 3.3
• Falcon-Serie: Einschließlich Falcon-180B
• GPT-Serie: ChatGPT-bezogene Architekturen
• Gemma-Serie: Googles Open-Source-Modelle
• Mixtral-Serie: Modelle mit gemischten Experten
• DeepSeek-Serie: Einschließlich DeepSeek R1
• CodeLlama: Spezielles Modell zur Code-Generierung

Ökosystem-Integration

NVIDIA-Ökosystem

• NVIDIA NeMo: End-to-End-Framework zum Erstellen, Anpassen und Bereitstellen generativer KI-Anwendungen
• Triton Inference Server: Inferenzserver für den Produktionseinsatz
• NVIDIA Dynamo: Framework für verteilte Inferenzdienste im Rechenzentrum

Drittanbieter-Integration

• HuggingFace Hub: Bietet vorquantisierte Modelle
• LlamaIndex: Entwicklung von RAG-Anwendungen
• SageMaker LMI: AWS Managed Inference

Leistungsbenchmarks

Beispiele für Leistungssteigerungen:

• Im Vergleich zu CPU-Plattformen: Inferenzgeschwindigkeit um bis zu 36-fach erhöht
• Im Vergleich zu RTX ohne Optimierung: Auf Windows RTX-Plattformen bis zu 4-fache Beschleunigung für große Sprachmodelle
• Falcon-180B: Inferenz auf einer einzelnen H200 GPU mit INT4 AWQ
• Llama-70B: 6,7-fache Geschwindigkeitssteigerung im Vergleich zu A100

Best Practices und Empfehlungen

Wahl der Quantisierungsmethode

Wählen Sie die geeignete Quantisierungsmethode je nach Szenario:

1. Inferenz mit kleinen Batches (Batch-Größe ≤4):

   • Empfohlen werden Gewichtungsquantisierungsmethoden (z. B. INT4 AWQ)
   • Hauptsächlich durch Speicherbandbreitenbeschränkungen beeinflusst

2. Inferenz mit großen Batches (Batch-Größe ≥16):

   • Bevorzugen Sie FP8-Quantisierung, die in der Regel die beste Leistung und Genauigkeit bietet
   • Wenn die Ergebnisse nicht zufriedenstellend sind, versuchen Sie INT8 SmoothQuant, gefolgt von AWQ und/oder GPTQ

3. Anwendungen in spezifischen Domänen:

   • Für hochspezialisierte Anwendungen wie Code-Vervollständigung wird empfohlen, domänenspezifische Datensätze zur Kalibrierung zu verwenden

Technische Vorteile

1. Benutzerfreundlichkeit: Bietet eine High-Level-Python-API, die den LLM-Definitions- und Optimierungsprozess vereinfacht
2. Leistung: Enthält alle gängigen Optimierungstechniken wie Kernel-Fusion, Quantisierung, Laufzeitoptimierung usw.
3. Skalierbarkeit: Unterstützt verschiedene Bereitstellungsszenarien von Einzel-GPU bis zu Multi-Node
4. Kompatibilität: Tief in PyTorch integriert und unterstützt die wichtigsten Inferenz-Ökosysteme
5. Open Source: Vollständig Open Source, gemeinschaftsgetriebene kontinuierliche Entwicklung

Zukünftige Entwicklung

TensorRT-LLM verbessert die Benutzerfreundlichkeit und Skalierbarkeit durch eine Open-Source-Modelldefinitions-API, um neue Architekturen und erweiterte Funktionen zu definieren, zu optimieren und auszuführen, die sich leicht an die Entwicklung von LLMs anpassen lassen.

Die kontinuierlichen Entwicklungsrichtungen des Projekts umfassen:

• Unterstützung weiterer Modellarchitekturen
• Fortschrittlichere Quantisierungstechniken
• Bessere Multi-Node-Skalierbarkeit
• Engere Ökosystem-Integration