Ir para o conteúdo principal
Português— Escolher um idioma
Menu

TensorRT-LLM e TGI

Aula 12 de 14 Atualizada a 29 de julho de 2026 Avancado
Nesta página
  1. Alternativas ao vLLM
  2. TensorRT-LLM
  3. TGI (Text Generation Inference)
  4. Comparação dos Três Motores
  5. Como Escolher Entre os Três
  6. Pontos-chave

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ériovLLMTensorRT-LLMTGI
DesempenhoExcelenteMáximoBom
Facilidade de UsoSimplesComplexoSimples
API OpenAINativaVia TritonNativa
QuantificaçãoFP8, AWQFP8, INT8, INT4GPTQ, AWQ
Multi-GPUParalelismo de tensoresTensores + PipelineParalelismo de tensores
Construção NecessáriaNãoSim (longa)Não
HardwareNVIDIA + AMDApenas NVIDIANVIDIA + 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