Spring til hovedindhold
Dansk— Vælg et sprog
Menu

TensorRT-LLM og TGI

Lektion 12 af 14 Opdateret 29. juli 2026 Avanceret
På denne side
  1. Alternativer til vLLM
  2. TensorRT-LLM
  3. TGI (Text Generation Inference)
  4. Sammenligning af de tre motorer
  5. Valg mellem de tre
  6. Vigtige pointer

Alternativer til vLLM

Selvom vLLM er den anbefalede standardmotor, fortjener to alternativer din opmærksomhed: NVIDIAs TensorRT-LLM for maksimal ydeevne og Hugging Faces TGI (Text Generation Inference) for sit integrerede økosystem. Begge betjener de samme Mistral-modeller, men med modsatrettede filosofier – den ene kompilerer, den anden eksekverer. Dette valg binder din organisation langt ud over den indledende implementering.

TensorRT-LLM

TensorRT-LLM er NVIDIAs optimeringsframework til inferens. Det gør mere end blot at indlæse en model: det kompilerer den til en “engine”, der er specifikt optimeret til dit GPU, hvilket giver den bedst mulige ydeevne på NVIDIA-hardware. Arbejdsgangen består derfor af to distinkte trin: en build-fase, der producerer TensorRT-engine’en, efterfulgt af en serve-fase, der udruller den via Triton Inference Server. Denne adskillelse er nøglen til alt, der følger: du vinder ydeevne på build-tidspunktet, ikke ved runtime.

# 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

Gevinsterne er målelige: afhængigt af brugstilfældet viser TensorRT-LLM sig at være 30 % til 50 % hurtigere end vLLM. Det anvender kernel-optimeringer specifikke for hver GPU-arkitektur – Ampere, Hopper, Blackwell – tilbyder avanceret kvantisering i FP8, INT8 og INT4 med automatisk kalibrering og håndterer inflight batching for at maksimere gennemstrømningen.

Afværgningen er reel. Hver model skal kompileres til dit specifikke GPU, og denne kompilering tager alt fra tredive minutter til flere timer afhængigt af modellen. Skift af model kræver et nyt build, hvilket gør processen smertefuld, hvis du stadig tester forskellige muligheder. Desuden virker det kun på NVIDIA-hardware: der er ingen portabilitet til AMD eller andre platforme. Organisatorisk betyder det, at et team, der itererer på sin model hver uge, vil bruge mere tid på kompilering end på betjening.

Når engine’en er bygget, overtager Triton og eksponerer tjenesten:

# 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 er Hugging Faces inferens-toolkit. Det indtager en mellemposition: mindre optimeret end TensorRT-LLM, men enklere at sætte op og perfekt integreret i Hugging Face-økosystemet, hvorfra du sandsynligvis allerede henter dine weights. Implementering kræver blot en enkelt 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

Serveren bliver tilgængelig på port 8080, når modellen er indlæst. Den leveres med indbygget kvantisering (GPTQ, AWQ, bitsandbytes), tensor-parallelisme til at fordele modellen på tværs af flere GPU’er, token-for-token streaming og continuous batching, der automatisk grupperer samtidige anmodninger i stedet for at behandle dem én efter én.

I produktion hjælper nogle få ekstra indstillinger med at begrænse hukommelsesforbruget:

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 maksimale prompt-længde, --max-total-tokens begrænser den kombinerede prompt og generering, og --quantize aktiverer kvantisering for at reducere GPU-footprintet. Præcis justering af disse værdier beskytter dig mod en usædvanligt lang anmodning, der kunne mætte hukommelsen og bringe tjenesten ned for alle.

På klientsiden eksponerer TGI en API, der er kompatibel med både Mistral-klienten og OpenAI-klienten, så du kan genbruge eksisterende kode:

# 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)

En nativ API forbliver tilgængelig for integrationer, der ikke bruger et 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}
    }'

Sammenligning af de tre motorer

KriteriumvLLMTensorRT-LLMTGI
YdeevneFremragendeMaksimalGod
BrugervenlighedEnkelKompleksEnkel
OpenAI APINatívVia TritonNatív
KvantiseringFP8, AWQFP8, INT8, INT4GPTQ, AWQ
Multi-GPUTensor parallelTensor + PipelineTensor parallel
Build påkrævetNejJa (lang)Nej
HardwareNVIDIA + AMDKun NVIDIANVIDIA + AMD

Valg mellem de tre

vLLM forbliver standardvalget, og med god grund: du kommer hurtigt i gang, du har en OpenAI-kompatibel API, og du kan skifte modeller uden at genopbygge noget. Et team, der stadig er i udforskningsfasen, har ingen interesse i at påtvinge sig selv noget andet.

TensorRT-LLM er berettiget i et specifikt scenarie: en fast model betjent i produktion ved meget høj gennemstrømning, udelukkende på NVIDIA-hardware, med et MLOps-team, der er i stand til at administrere build-pipelinen. Hvis blot ét af disse fire elementer mangler, vil gevinsten på 30 % til 50 % i ydeevne blive ædt op af tiden brugt på at vedligeholde kompileringen.

Endelig er TGI det naturlige valg, hvis du allerede lever i Hugging Face-økosystemet, ønsker kvantisering uden yderligere konfiguration og leder efter en enkel Docker-løsning, som et team uden inferens-specialisering kan adoptere.

Vigtige pointer

  • TensorRT-LLM tilbyder den bedste ydeevne, men kræver et specifikt build per GPU
  • TGI er Hugging Faces toolkit med indbygget kvantisering, tensor-parallelisme og batching
  • vLLM forbliver det bedste kompromis mellem ydeevne og enkelthed for de fleste brugstilfælde
  • Alle tre motorer eksponerer en OpenAI-kompatibel API (direkte eller via Triton)
  • Dit valg afhænger af dit volumen, din hardware og din tolerance over for kompleksitet