TensorRT-LLM e TGI
Nesta página
Alternativas ao vLLM
Embora o vLLM seja o motor predefinido recomendado, duas alternativas merecem a sua atenção: o TensorRT-LLM da NVIDIA para desempenho máximo, e o TGI (Text Generation Inference) da Hugging Face pelo seu ecossistema integrado. Ambos servem os mesmos modelos Mistral, mas com filosofias opostas: um compila, o outro executa. Esta escolha compromete a sua organização muito para além da implementação inicial.
TensorRT-LLM
O TensorRT-LLM é a estrutura de otimização de inferência da NVIDIA. Faz mais do que simplesmente carregar um modelo: compila-o num “motor” otimizado especificamente para o seu GPU, oferecendo o melhor desempenho possível em hardware NVIDIA. O fluxo de trabalho consiste, portanto, em duas etapas distintas: uma fase de construção que produz o motor TensorRT, seguida de uma fase de serviço que o implementa através do Triton Inference Server. Esta separação é fundamental para tudo o que se segue: ganha desempenho no momento da construção, não em tempo de execução.
# 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
Os ganhos são mensuráveis: dependendo do caso de uso, o TensorRT-LLM revela-se 30% a 50% mais rápido que o vLLM. Aplica otimizações de kernel específicas para cada arquitetura de GPU — Ampere, Hopper, Blackwell —, oferece quantificação avançada em FP8, INT8 e INT4 com calibração automática e gere o inflight batching para maximizar a taxa de transferência.
A contrapartida é real. Cada modelo deve ser compilado para o seu GPU específico, e esta compilação demora entre trinta minutos e várias horas, dependendo do modelo. Alterar modelos exige uma nova construção, tornando o processo penoso se ainda estiver a testar diferentes opções. Além disso, funciona apenas em hardware NVIDIA: não há portabilidade para AMD ou outras plataformas. Em termos organizacionais, isto significa que uma equipa que itere sobre o seu modelo todas as semanas passará mais tempo a compilar do que a servir.
Uma vez construído o motor, o Triton assume o controlo e expõe o serviço:
# 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)
O TGI é o kit de ferramentas de inferência da Hugging Face. Ocupa um meio-termo: menos otimizado que o TensorRT-LLM, mas mais simples de configurar e perfeitamente integrado no ecossistema Hugging Face, de onde provavelmente já obtém os seus pesos. A implementação requer apenas um comando 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
O servidor torna-se acessível na porta 8080 assim que o modelo carrega. Inclui quantificação integrada (GPTQ, AWQ, bitsandbytes), paralelismo de tensores para distribuir o modelo por vários GPUs, streaming token-a-token e continuous batching, que agrupa automaticamente pedidos concorrentes em vez de os processar um após o outro.
Em produção, algumas definições adicionais ajudam a conter o consumo de memória:
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 define o comprimento máximo do prompt, --max-total-tokens limita o total combinado de prompt e geração, e --quantize ativa a quantificação para reduzir a pegada no GPU. Ajustar estes valores com precisão protege-o de um pedido invulgarmente longo que possa saturar a memória e derrubar o serviço para todos.
Do lado do cliente, o TGI expõe uma API compatível tanto com o cliente Mistral como com o cliente OpenAI, permitindo-lhe reutilizar código existente:
# 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)
Uma API nativa permanece disponível para integrações que não utilizam um 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}
}'
Comparação dos Três Motores
| Critério | vLLM | TensorRT-LLM | TGI |
|---|---|---|---|
| Desempenho | Excelente | Máximo | Bom |
| Facilidade de Uso | Simples | Complexo | Simples |
| API OpenAI | Nativa | Via Triton | Nativa |
| Quantificação | FP8, AWQ | FP8, INT8, INT4 | GPTQ, AWQ |
| Multi-GPU | Paralelismo de tensores | Tensores + Pipeline | Paralelismo de tensores |
| Construção Necessária | Não | Sim (longa) | Não |
| Hardware | NVIDIA + AMD | Apenas NVIDIA | NVIDIA + AMD |
Como Escolher Entre os Três
O vLLM permanece a escolha predefinida, e por boas razões: coloca-o a funcionar rapidamente, dispõe de uma API compatível com a OpenAI e pode mudar de modelos sem reconstruir nada. Uma equipa ainda na fase de exploração não tem interesse em impor-se qualquer outra coisa.
O TensorRT-LLM justifica-se num cenário específico: um modelo fixo servido em produção com taxa de transferência muito elevada, em hardware exclusivamente NVIDIA, com uma equipa de MLOps capaz de gerir o pipeline de construção. Se faltar algum destes quatro elementos, o ganho de desempenho de 30% a 50% será consumido pelo tempo gasto na manutenção da compilação.
Por fim, o TGI é a escolha natural se já vive no ecossistema Hugging Face, quer quantificação sem configuração adicional e procura uma solução Docker simples que uma equipa sem especialização em inferência possa adotar.
Pontos-chave
- O TensorRT-LLM oferece o melhor desempenho, mas exige uma construção específica por GPU
- O TGI é o kit de ferramentas da Hugging Face com quantificação integrada, paralelismo de tensores e batching
- O vLLM permanece o melhor compromisso entre desempenho e simplicidade para a maioria dos casos de uso
- Os três motores expõem uma API compatível com a OpenAI (diretamente ou via Triton)
- A sua escolha depende do seu volume, hardware e tolerância à complexidade