TensorRT-LLM en TGI
Op deze pagina
Alternatieven voor vLLM
Hoewel vLLM de aanbevolen standaardengine is, verdienen twee alternatieven uw aandacht: NVIDIA’s TensorRT-LLM voor maximale prestaties, en Hugging Face’s TGI (Text Generation Inference) voor zijn geïntegreerde ecosysteem. Beide bedienen dezelfde Mistral-modellen, maar hanteren tegenovergestelde filosofieën: de ene compileert, de andere voert uit. Deze keuze bindt uw organisatie langdurig, ver voorbij de initiële implementatie.
TensorRT-LLM
TensorRT-LLM is het optimalisatieframework voor inferentie van NVIDIA. Het doet meer dan alleen een model laden: het compileert het tot een “engine” die specifiek is geoptimaliseerd voor uw GPU, wat de best mogelijke prestaties op NVIDIA-hardware oplevert. De workflow bestaat daarom uit twee distincte stappen: een build-fase die de TensorRT-engine produceert, gevolgd door een serve-fase die deze via Triton Inference Server implementeert. Deze scheiding is cruciaal voor alles wat volgt: u wint prestaties tijdens het bouwen, niet tijdens het uitvoeren.
# Step 1: Clone the TensorRT-LLM repository
git clone https://github.com/NVIDIA/TensorRT-LLM.git
cd TensorRT-LLM
# Step 2: Build the engine (Mistral 7B example)
# Mistral models use the LLaMA example from the repository
python examples/llama/convert_checkpoint.py \
--model_dir mistralai/Mistral-7B-Instruct-v0.3 \
--output_dir ./checkpoint \
--dtype float16
python -m tensorrt_llm.commands.build \
--checkpoint_dir ./checkpoint \
--output_dir ./engine \
--gemm_plugin float16
De winst is meetbaar: afhankelijk van het gebruiksscenario bewijst TensorRT-LLM 30% tot 50% sneller te zijn dan vLLM. Het past kerneloptimalisaties toe die specifiek zijn voor elke GPU-architectuur (Ampere, Hopper, Blackwell), biedt geavanceerde kwantisatie in FP8, INT8 en INT4 met automatische kalibratie, en behandelt inflight batching om de doorvoer te maximaliseren.
De afweging is reëel. Elk model moet voor uw specifieke GPU worden gecompileerd, en deze compilatie duurt ergens tussen dertig minuten en enkele uren, afhankelijk van het model. Het wisselen van modellen vereist een nieuwe build, wat het proces pijnlijk maakt als u nog verschillende opties test. Bovendien werkt het alleen op NVIDIA-hardware: er is geen portabiliteit naar AMD of andere platformen. In organisatorische termen betekent dit dat een team dat elke week iteratie op zijn model toepast, meer tijd besteedt aan compileren dan aan het bedienen van aanvragen.
Zodra de engine is gebouwd, neemt Triton het over en stelt de dienst beschikbaar:
# Launch Triton Inference Server with the engine
docker run --rm --gpus all \
-v ./engine:/models/mistral/1 \
-p 8000:8000 \
nvcr.io/nvidia/tritonserver:latest \
tritonserver --model-repository=/models
TGI (Text Generation Inference)
TGI is de inferentie-toolkit van Hugging Face. Het bezet een middenpositie: minder geoptimaliseerd dan TensorRT-LLM, maar eenvoudiger op te zetten en perfect geïntegreerd in het Hugging Face-ecosysteem waaruit u waarschijnlijk al uw weights haalt. Implementatie vereist slechts één Docker-opdracht:
docker run --gpus all --shm-size 1g \
-p 8080:80 \
-e HUGGING_FACE_HUB_TOKEN=$HF_TOKEN \
ghcr.io/huggingface/text-generation-inference:2.0.3 \
--model-id mistralai/Mistral-7B-Instruct-v0.3
De server wordt beschikbaar op poort 8080 zodra het model is geladen. Het wordt geleverd met ingebouwde kwantisatie (GPTQ, AWQ, bitsandbytes), tensor-parallelisme om het model over meerdere GPU’s te verdelen, token-per-token streaming en continuous batching, dat gelijktijdige aanvragen automatisch groepeert in plaats van ze één voor één te verwerken.
In productie helpen een paar extra instellingen om het geheugengebruik te beperken:
docker run --gpus all --shm-size 1g \
-p 8080:80 \
-e HUGGING_FACE_HUB_TOKEN=$HF_TOKEN \
ghcr.io/huggingface/text-generation-inference:2.0.3 \
--model-id mistralai/Mistral-7B-Instruct-v0.3 \
--max-input-length 4096 \
--max-total-tokens 8192 \
--max-batch-prefill-tokens 4096 \
--quantize awq
--max-input-length stelt de maximale promptlengte in, --max-total-tokens limiteert de gecombineerde prompt en generatie, en --quantize schakelt kwantisatie in om de GPU-voetafdruk te verkleinen. Het nauwkeurig afstemmen van deze waarden beschermt u tegen een ongebruikelijk lange aanvraag die het geheugen zou kunnen verzadigen en de dienst voor iedereen zou kunnen platleggen.
Aan de clientzijde exposeert TGI een API die compatibel is met zowel de Mistral-client als de OpenAI-client, waardoor u bestaande code kunt hergebruiken:
# Using the OpenAI client
from openai import OpenAI
client = OpenAI(
base_url="http://localhost:8080/v1",
api_key="not-needed"
)
response = client.chat.completions.create(
model="mistralai/Mistral-7B-Instruct-v0.3",
messages=[{"role": "user", "content": "Explain continuous batching."}],
max_tokens=512
)
print(response.choices[0].message.content)
Een native API blijft beschikbaar voor integraties die geen SDK gebruiken:
# Using curl (TGI native API)
curl http://localhost:8080/generate \
-H "Content-Type: application/json" \
-d '{
"inputs": "Explain continuous batching.",
"parameters": {"max_new_tokens": 512}
}'
Vergelijking van de drie engines
| Criterium | vLLM | TensorRT-LLM | TGI |
|---|---|---|---|
| Prestaties | Uitstekend | Maximaal | Goed |
| Gebruiksgemak | Eenvoudig | Complex | Eenvoudig |
| OpenAI API | Native | Via Triton | Native |
| Kwantisatie | FP8, AWQ | FP8, INT8, INT4 | GPTQ, AWQ |
| Multi-GPU | Tensor parallel | Tensor + Pipeline | Tensor parallel |
| Build vereist | Nee | Ja (lang) | Nee |
| Hardware | NVIDIA + AMD | Alleen NVIDIA | NVIDIA + AMD |
Kiezen tussen de drie
vLLM blijft de standaardkeuze, en dat met reden: u bent snel operationeel, u heeft een OpenAI-compatibele API en u kunt van model wisselen zonder iets opnieuw te bouwen. Een team dat zich nog in de verkenningsfase bevindt, heeft er geen belang bij zich iets anders op te leggen.
TensorRT-LLM is gerechtvaardigd in een specifiek scenario: een vast model dat in productie wordt bediend met een zeer hoge doorvoer, op uitsluitend NVIDIA-hardware, met een MLOps-team dat de build-pipeline kan beheren. Als ook maar één van deze vier elementen ontbreekt, wordt de prestatiewinst van 30% tot 50% opgegeten door de tijd die wordt besteed aan het onderhouden van de compilatie.
Tot slot is TGI de natuurlijke keuze als u al in het Hugging Face-ecosysteem werkt, kwantisatie wilt zonder extra configuratie, en op zoek bent naar een eenvoudige Docker-oplossing die een team zonder specialisatie in inferentie kan adopteren.
Belangrijkste punten
- TensorRT-LLM biedt de beste prestaties, maar vereist een specifieke build per GPU
- TGI is de toolkit van Hugging Face met ingebouwde kwantisatie, tensor-parallelisme en batching
- vLLM blijft het beste compromis tussen prestaties en eenvoud voor de meeste use cases
- Alle drie de engines exposeren een OpenAI-compatibele API (direct of via Triton)
- Uw keuze hangt af van uw volume, hardware en tolerantie voor complexiteit