Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

TensorRT-LLM en TGI

Les 12 van 14 Bijgewerkt op 29 juli 2026 Gevorderd
Op deze pagina
  1. Alternatieven voor vLLM
  2. TensorRT-LLM
  3. TGI (Text Generation Inference)
  4. Vergelijking van de drie engines
  5. Kiezen tussen de drie
  6. Belangrijkste punten

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

CriteriumvLLMTensorRT-LLMTGI
PrestatiesUitstekendMaximaalGoed
GebruiksgemakEenvoudigComplexEenvoudig
OpenAI APINativeVia TritonNative
KwantisatieFP8, AWQFP8, INT8, INT4GPTQ, AWQ
Multi-GPUTensor parallelTensor + PipelineTensor parallel
Build vereistNeeJa (lang)Nee
HardwareNVIDIA + AMDAlleen NVIDIANVIDIA + 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