Introdução Detalhada ao Projeto TensorRT-LLM

Visão Geral do Projeto

TensorRT-LLM é uma biblioteca de código aberto desenvolvida pela NVIDIA, especializada na otimização do desempenho de inferência de Grandes Modelos de Linguagem (LLM) em GPUs NVIDIA. Ela oferece uma API Python fácil de usar para definir LLMs e suporta as mais avançadas técnicas de otimização para executar inferência de forma eficiente em GPUs NVIDIA.

Principais Recursos

1. Técnicas de Otimização Avançadas

TensorRT-LLM oferece diversas funcionalidades de otimização avançadas, incluindo:

• Kernels de Atenção Personalizados: Implementações de mecanismos de atenção especialmente otimizados
• Processamento em Lotes Dinâmico (Inflight Batching): Processamento em tempo real de sequências de entrada de diferentes comprimentos
• Cache KV Paginado: Gerenciamento eficiente do cache de chave-valor
• Decodificação Especulativa (Speculative Decoding): Acelera a geração prevendo múltiplos tokens
• Suporte a Múltiplas Quantizações: FP8, FP4, INT4 AWQ, INT8 SmoothQuant, entre outros

2. Detalhes das Técnicas de Quantização

TensorRT-LLM oferece um kit de ferramentas de quantização unificado líder da indústria, que acelera significativamente a implantação de Deep Learning/IA Generativa em hardware NVIDIA, mantendo a precisão do modelo.

Principais Métodos de Quantização:

• FP8: Geralmente oferece o melhor desempenho e precisão em cenários de inferência com grandes lotes (batch size ≥ 16)
• INT8 SmoothQuant: Suavização de pesos e quantização de canal INT8, com calibração de faixa de ativação em nível de tensor
• INT4 AWQ: Reescalonamento de pesos e quantização em nível de bloco para INT4, recomendado para cenários de inferência com pequenos lotes (batch size ≤ 4)
• W4A8 AWQ: Quantização de pesos para INT4, quantização de ativações para INT8

Melhorias de Desempenho:

De acordo com os testes de benchmark, as técnicas de quantização podem proporcionar melhorias significativas de desempenho:

• Quantização FP8: Em comparação com o benchmark FP16, o modelo Llama 3 8B pode obter uma aceleração de 1,45x, e o modelo 70B, uma aceleração de 1,81x
• INT4 AWQ: Em cenários com batch size de 1, o modelo 70B pode obter um aumento de desempenho de até 2,66x
• Otimização de Memória: Todas as versões quantizadas do modelo Llama 3 70B podem ser executadas em uma única GPU NVIDIA H100, enquanto a precisão FP16 requer pelo menos duas GPUs

3. Suporte a Múltiplas GPUs e Múltiplos Nós

TensorRT-LLM inclui etapas de pré-processamento e pós-processamento, bem como primitivas de comunicação multi-GPU e multi-nó, alcançando um desempenho de inferência de LLM inovador através de uma API de definição de modelo simples e de código aberto.

4. Amplo Suporte de Hardware

TensorRT-LLM suporta GPUs baseadas nas arquiteturas NVIDIA Hopper, NVIDIA Ada Lovelace e NVIDIA Ampere. Em particular:

• GPU H100: Suporta conversão automática e kernels otimizados para o formato FP8
• GPU H200: Pode atingir quase 12.000 tokens/segundo no Llama2-13B
• Série RTX: Suporta inferência de grandes modelos em GPUs de consumo

Instalação e Uso

Instalação via Docker (Recomendado)

# Executar o contêiner Docker pré-construído
docker run --ipc host --gpus all -it nvcr.io/nvidia/tensorrt-llm/release

Exemplo de Uso da API LLM

from tensorrt_llm import BuildConfig, SamplingParams
from tensorrt_llm._tensorrt_engine import LLM

def main():
    build_config = BuildConfig()
    build_config.max_batch_size = 256
    build_config.max_num_tokens = 1024
    
    # Suporta nomes de modelos HuggingFace, caminhos de modelos HF locais ou checkpoints de quantização do otimizador de modelos TensorRT
    llm = LLM(model="TinyLlama/TinyLlama-1.1B-Chat-v1.0", 
              build_config=build_config)
    
    # Exemplos de prompts
    prompts = [
        "Hello, my name is",
        "The capital of France is",
        "The future of AI is",
    ]
    
    # Criar parâmetros de amostragem
    sampling_params = SamplingParams(temperature=0.8, top_p=0.95)
    
    for output in llm.generate(prompts, sampling_params):
        print(f"Prompt: {output.prompt!r}, Generated text: {output.outputs[0].text!r}")

Implantação de Serviço Online

# Iniciar o servidor compatível com OpenAI
trtllm-serve --model TinyLlama/TinyLlama-1.1B-Chat-v1.0 --port 8000

Fluxo de Trabalho de Quantização

Comandos Básicos de Quantização

# Quantização FP8
python quantize.py --model_dir $MODEL_PATH --qformat fp8 --kv_cache_dtype fp8 --output_dir $OUTPUT_PATH

# Quantização INT4 AWQ
python quantize.py --model_dir $MODEL_PATH --qformat int4_awq --awq_block_size 64 --tp_size 4 --output_dir $OUTPUT_PATH

# Quantização INT8 SmoothQuant
python quantize.py --model_dir $MODEL_PATH --qformat int8_sq --kv_cache_dtype int8 --output_dir $OUTPUT_PATH

# Auto-quantização (combinação de múltiplos métodos)
python quantize.py --model_dir $MODEL_PATH --autoq_format fp8,int4_awq,w4a8_awq --output_dir $OUTPUT_PATH --auto_quantize_bits 5 --tp_size 2

Modelos Suportados

TensorRT-LLM suporta uma vasta gama de arquiteturas LLM populares, incluindo, mas não se limitando a:

• Série Llama: Llama 2, Llama 3, Llama 3.1, Llama 3.3
• Série Falcon: Incluindo Falcon-180B
• Série GPT: Arquiteturas relacionadas ao ChatGPT
• Série Gemma: Modelos de código aberto do Google
• Série Mixtral: Modelos de especialistas mistos
• Série DeepSeek: Incluindo DeepSeek R1
• CodeLlama: Modelo especializado em geração de código

Integração com o Ecossistema

Ecossistema NVIDIA

• NVIDIA NeMo: Framework ponta a ponta para construir, personalizar e implantar aplicações de IA generativa
• Triton Inference Server: Servidor de inferência de nível de produção
• NVIDIA Dynamo: Framework de serviço de inferência distribuída em escala de data center

Integrações de Terceiros

• HuggingFace Hub: Oferece modelos pré-quantizados
• LlamaIndex: Desenvolvimento de aplicações RAG
• SageMaker LMI: Inferência gerenciada pela AWS

Benchmarks de Desempenho

Exemplos de Melhoria de Desempenho:

• Em comparação com plataformas de CPU: Velocidade de inferência aumentada em até 36x
• Em comparação com RTX sem otimização: Velocidade de LLMs aumentada em até 4x em plataformas Windows RTX
• Falcon-180B: Inferência em uma única GPU H200 usando INT4 AWQ
• Llama-70B: Aumento de velocidade de 6,7x em comparação com A100

Recomendações de Melhores Práticas

Seleção do Método de Quantização

Escolha o método de quantização apropriado com base em diferentes cenários:

1. Inferência com Pequenos Lotes (batch size ≤ 4):

   • Recomenda-se o uso de métodos de quantização de pesos (como INT4 AWQ)
   • Principalmente devido às limitações de largura de banda da memória

2. Inferência com Grandes Lotes (batch size ≥ 16):

   • Priorize a quantização FP8, que geralmente oferece o melhor desempenho e precisão
   • Se os resultados não forem satisfatórios, tente INT8 SmoothQuant, seguido por AWQ e/ou GPTQ

3. Aplicações de Domínio Específico:

   • Para aplicações altamente especializadas, como preenchimento de código, recomenda-se usar conjuntos de dados específicos do domínio para calibração

Vantagens Técnicas

1. Facilidade de Uso: Oferece uma API Python de alto nível, simplificando a definição e o processo de otimização de LLMs
2. Desempenho: Inclui todas as principais técnicas de otimização, como fusão de kernels, quantização, otimização em tempo de execução, etc.
3. Escalabilidade: Suporta vários cenários de implantação, desde uma única GPU até múltiplos nós
4. Compatibilidade: Profundamente integrado com PyTorch, suporta os principais ecossistemas de inferência
5. Código Aberto: Totalmente de código aberto, com desenvolvimento contínuo impulsionado pela comunidade

Desenvolvimento Futuro

TensorRT-LLM aumenta a facilidade de uso e a escalabilidade através de uma API de definição de modelo modular de código aberto, para definir, otimizar e executar novas arquiteturas e funcionalidades aprimoradas, que podem ser facilmente personalizadas à medida que os LLMs evoluem.

As direções de desenvolvimento contínuo do projeto incluem:

• Mais suporte a arquiteturas de modelos
• Técnicas de quantização mais avançadas
• Melhor capacidade de escalabilidade multi-nó
• Integração mais estreita com o ecossistema