Przejdź do głównej treści
Polski— Wybierz język
Menu

TensorRT-LLM i TGI

Lekcja 12 z 14 Zaktualizowano 29 lipca 2026 Zaawansowany
Na tej stronie
  1. Alternatywy dla vLLM
  2. TensorRT-LLM
  3. TGI (Text Generation Inference)
  4. Porównanie trzech silników
  5. Wybór między trzema opcjami
  6. Kluczowe wnioski

Alternatywy dla vLLM

Chociaż vLLM jest zalecanym domyślnym silnikiem, dwie alternatywy zasługują na Twoją uwagę: TensorRT-LLM od NVIDIA dla maksymalnej wydajności oraz TGI (Text Generation Inference) od Hugging Face dla jego zintegrowanego ekosystemu. Obie obsługują te same modele Mistral, ale kierują się przeciwstawnymi filozofiami – jedna kompiluje, druga wykonuje. Ten wybór zobowiązuje Twoją organizację na długo poza etapem początkowego wdrożenia.

TensorRT-LLM

TensorRT-LLM to framework optymalizacji wnioskowania od NVIDIA. Robi więcej niż tylko ładuje model: kompiluje go w „silnik“ zoptymalizowany specjalnie pod Twój GPU, zapewniając najlepszą możliwą wydajność na sprzęcie NVIDIA. Proces składa się zatem z dwóch odrębnych kroków: fazy build, która tworzy silnik TensorRT, oraz fazy serve, która wdraża go za pomocą Triton Inference Server. To rozdzielenie jest kluczowe dla wszystkiego, co następuje: zyskujesz na wydajności w czasie kompilacji, a nie w czasie działania.

# 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

Korzyści są wymierne: w zależności od przypadku użycia, TensorRT-LLM okazuje się o 30% do 50% szybszy niż vLLM. Stosuje optymalizacje jąder specyficzne dla każdej architektury GPU – Ampere, Hopper, Blackwell – oferuje zaawansowaną kwantyzację w formatach FP8, INT8 i INT4 z automatyczną kalibracją oraz obsługuje wsadowanie w locie (inflight batching), aby zmaksymalizować przepustowość.

Kompromis jest jednak realny. Każdy model musi zostać skompilowany pod konkretny GPU, a kompilacja ta trwa od trzydziestu minut do kilku godzin, w zależności od modelu. Zmiana modelu wymaga nowej kompilacji, co czyni proces bolesnym, jeśli nadal testujesz różne opcje. Co więcej, działa to wyłącznie na sprzęcie NVIDIA: nie ma przenośności na platformy AMD ani inne. W kontekście organizacyjnym oznacza to, że zespół iterujący nad modelem co tydzień spędzi więcej czasu na kompilacji niż na obsłudze.

Gdy silnik zostanie już zbudowany, Triton przejmuje kontrolę i udostępnia usługę:

# 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 to zestaw narzędzi do wnioskowania od Hugging Face. Zajmuje pozycję pośrednią: mniej zoptymalizowany niż TensorRT-LLM, ale prostszy w konfiguracji i idealnie zintegrowany z ekosystemem Hugging Face, z którego prawdopodobnie już pobierasz wagi. Wdrożenie wymaga jedynie jednego polecenia Docker:

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

Serwer staje się dostępny na porcie 8080 po załadowaniu modelu. Posiada wbudowaną kwantyzację (GPTQ, AWQ, bitsandbytes), równoległość tensorową do rozkładania modelu na wiele GPU, strumieniowanie token po tokenie oraz ciągłe wsadowanie (continuous batching), które automatycznie grupuje współbieżne żądania zamiast przetwarzać je jedno po drugim.

W środowisku produkcyjnym kilka dodatkowych ustawień pomaga ograniczyć zużycie pamięci:

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 ustawia maksymalną długość promptu, --max-total-tokens ogranicza łączną liczbę tokenów promptu i generacji, a --quantize włącza kwantyzację, aby zmniejszyć footprint na GPU. Precyzyjne dostrojenie tych wartości chroni Cię przed nietypowo długim żądaniem, które mogłoby nasycić pamięć i wyłączyć usługę dla wszystkich.

Po stronie klienta TGI udostępnia API kompatybilne zarówno z klientem Mistral, jak i klientem OpenAI, co pozwala na ponowne wykorzystanie istniejącego kodu:

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

Dostępne jest również natywne API dla integracji, które nie używają 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}
    }'

Porównanie trzech silników

KryteriumvLLMTensorRT-LLMTGI
WydajnośćDoskonałaMaksymalnaDobra
Łatwość użyciaProstaZłożonaProsta
API OpenAINatywnePrzez TritonNatywne
KwantyzacjaFP8, AWQFP8, INT8, INT4GPTQ, AWQ
Multi-GPURównoległość tensorowaTensorowa + potokowaRównoległość tensorowa
Wymagany buildNieTak (długi)Nie
SprzętNVIDIA + AMDTylko NVIDIANVIDIA + AMD

Wybór między trzema opcjami

vLLM pozostaje wyborem domyślnym i nie bez powodu: szybko zaczynasz pracę, masz API kompatybilne z OpenAI i możesz zmieniać modele bez konieczności ponownej kompilacji. Zespół będący wciąż na etapie eksploracji nie ma interesu w narzucaniu sobie czegoś innego.

TensorRT-LLM jest uzasadniony w konkretnym scenariuszu: stały model obsługiwany w produkcji przy bardzo wysokiej przepustowości, wyłącznie na sprzęcie NVIDIA, z zespołem MLOps zdolnym do zarządzania potokiem kompilacji. Jeśli brakuje któregokolwiek z tych czterech elementów, zysk wydajnościowy rzędu 30% do 50% zostanie pochłonięty przez czas spędzony na utrzymaniu kompilacji.

Wreszcie, TGI jest naturalnym wyborem, jeśli już działasz w ekosystemie Hugging Face, chcesz kwantyzacji bez dodatkowej konfiguracji i szukasz prostego rozwiązania Docker, które może przyjąć zespół bez specjalizacji w wnioskowaniu.

Kluczowe wnioski

  • TensorRT-LLM oferuje najlepszą wydajność, ale wymaga osobnego buildu dla każdego GPU
  • TGI to zestaw narzędzi Hugging Face z wbudowaną kwantyzacją, równoległością tensorową i wsadowaniem
  • vLLM pozostaje najlepszym kompromisem między wydajnością a prostotą dla większości przypadków użycia
  • Wszystkie trzy silniki udostępniają API kompatybilne z OpenAI (bezpośrednio lub przez Triton)
  • Twój wybór zależy od wolumenu, sprzętu i tolerancji na złożoność