TensorRT-LLM och TGI
På denna sida
Alternativ till vLLM
Även om vLLM är den rekommenderade standardmotorn, finns det två alternativ som förtjänar din uppmärksamhet: NVIDIAs TensorRT-LLM för maximal prestanda, och Hugging Faces TGI (Text Generation Inference) för dess integrerade ekosystem. Båda servar samma Mistral-modeller, men med motsatta filosofier – den ena kompilerar, den andra exekuterar. Detta val binder din organisation långt bortom den första implementeringen.
TensorRT-LLM
TensorRT-LLM är NVIDIAs ramverk för inferensoptimering. Det gör mer än att bara ladda en modell: det kompilerar den till en “motor” som är specifikt optimerad för ditt GPU, vilket ger bästa möjliga prestanda på NVIDIA-hårdvara. Arbetsflödet består därför av två distinkta steg: en build-fas som producerar TensorRT-motorn, följt av en serve-fas som distribuerar den via Triton Inference Server. Denna separation är nyckeln till allt som följer: du vinner prestanda vid byggtid, inte vid körtid.
# 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
Vinsterna är mätbara: beroende på användningsfall visar sig TensorRT-LLM vara 30 % till 50 % snabbare än vLLM. Det applicerar kerneloptimeringar specifika för varje GPU-arkitektur – Ampere, Hopper, Blackwell – erbjuder avancerad kvantisering i FP8, INT8 och INT4 med automatisk kalibrering, och hanterar inflight-batching för att maximera genomströmningen.
Avvägningen är verklig. Varje modell måste kompileras för ditt specifika GPU, och denna kompilering tar allt från trettio minuter till flera timmar beroende på modellen. Att byta modell kräver en ny byggnation, vilket gör processen smärtsam om du fortfarande testar olika alternativ. Dessutom fungerar det endast på NVIDIA-hårdvara: det finns ingen portabilitet till AMD eller andra plattformar. Organisationsmässigt innebär detta att ett team som itererar över sin modell varje vecka kommer att spendera mer tid på att kompilera än att serva.
När motorn väl är byggd tar Triton över och exponerar tjänsten:
# 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 är Hugging Faces inferensverktygslåda. Det intar en mellanposition: mindre optimerat än TensorRT-LLM, men enklare att sätta upp och perfekt integrerat i Hugging Face-ekosystemet där du sannolikt redan hämtar dina vikter. Distributionen kräver bara ett enda Docker-kommando:
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
Servern blir tillgänglig på port 8080 när modellen har laddats. Den levereras med inbyggd kvantisering (GPTQ, AWQ, bitsandbytes), tensorparallellism för att distribuera modellen över flera GPU:er, token-för-token-strömning och kontinuerlig batching, som automatiskt grupperar samtidiga förfrågningar istället för att bearbeta dem en efter en.
I produktion hjälper några ytterligare inställningar till att begränsa minnesanvändningen:
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 sätter den maximala promptlängden, --max-total-tokens begränsar den kombinerade längden för prompt och generering, och --quantize aktiverar kvantisering för att minska GPU-minnesfootprinten. Att finjustera dessa värden exakt skyddar dig från en ovanligt lång förfrågan som skulle kunna mätta minnet och få tjänsten att krascha för alla.
På klientsidan exponerar TGI ett API som är kompatibelt med både Mistral-klienten och OpenAI-klienten, vilket låter dig återanvända befintlig kod:
# 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)
Ett inbyggt API finns också tillgängligt för integrationer som inte använder ett SDK:
# 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}
}'
Jämförelse av de tre motorerna
| Kriterium | vLLM | TensorRT-LLM | TGI |
|---|---|---|---|
| Prestanda | Utmärkt | Maximal | God |
| Användarvänlighet | Enkel | Komplex | Enkel |
| OpenAI API | Inbyggt | Via Triton | Inbyggt |
| Kvantisering | FP8, AWQ | FP8, INT8, INT4 | GPTQ, AWQ |
| Flera GPU:er | Tensorparallell | Tensor + Pipeline | Tensorparallell |
| Bygg krävs | Nej | Ja (långt) | Nej |
| Hårdvara | NVIDIA + AMD | Endast NVIDIA | NVIDIA + AMD |
Att välja mellan de tre
vLLM förblir det självklara valet, och av goda skäl: du kommer igång snabbt, du får ett OpenAI-kompatibelt API och du kan byta modeller utan att behöva bygga om något. Ett team som fortfarande befinner sig i en utforskande fas har inget intresse av att påtvinga sig självt något annat.
TensorRT-LLM är motiverat i ett specifikt scenario: en fast modell som servas i produktion vid mycket hög genomströmning, på uteslutande NVIDIA-hårdvara, med ett MLOps-team som kan hantera build-pipelinen. Om någon av dessa fyra element saknas, kommer prestandavinsten på 30 % till 50 % att ätas upp av den tid som spenderas på att underhålla kompileringen.
Slutligen är TGI det naturliga valet om du redan lever i Hugging Face-ekosystemet, vill ha kvantisering utan ytterligare konfiguration och söker en enkel Docker-lösning som ett team utan specialisering på inferens kan adoptera.
Viktiga punkter
- TensorRT-LLM erbjuder bäst prestanda men kräver en specifik byggnation per GPU
- TGI är Hugging Faces verktygslåda med inbyggd kvantisering, tensorparallellism och batching
- vLLM förblir den bästa kompromissen mellan prestanda och enkelhet för de flesta användningsfall
- Alla tre motorer exponerar ett OpenAI-kompatibelt API (direkt eller via Triton)
- Ditt val beror på din volym, hårdvara och tolerans för komplexitet