tensorrt cpp api

Tutorial da API Tensorrt C ++

Como usar a API do Tensorrt C ++ para inferência de aprendizado de máquina GPU de alto desempenho.
Suporta modelos com entradas únicas / múltiplas e saídas únicas / múltiplas com lote.

Visão geral do projeto Vídeo. Código de vídeo de mergulho profundo

Procurando mantenedores

Este projeto está buscando ativamente os mantenedores para ajudar a orientar seu crescimento e melhoria. Se você é apaixonado por esse projeto e interessado em contribuir, eu adoraria ouvir você!

Sinta -se à vontade para entrar em contato via LinkedIn para discutir como você pode se envolver.

Tutorial Tensorrt C ++

Eu li todos os documentos da Nvidia Tensorrt para que você não precise!

Este projeto demonstra como usar a API Tensorrt C ++ para inferência de GPU de alto desempenho nos dados da imagem. Abrange como fazer o seguinte:

• Como instalar o Tensorrt 10 no Ubuntu 20.04 / 22.04.
• Como gerar um arquivo de mecanismo Tensorrt otimizado para sua GPU.
• Como especificar um perfil de otimização simples.
• Como executar a inferência de precisão FP32, FP16 ou Int8.
• Como ler / gravar dados de / para a memória da GPU e trabalhar com imagens de GPU.
• Como usar o fluxo CUDA para executar a inferência assíncrona e sincronizar posteriormente.
• Como trabalhar com modelos com tamanhos de lote estáticos e dinâmicos.
• Como trabalhar com modelos com tensores de saída únicos ou múltiplos.
• Como trabalhar com modelos com várias entradas.
• Inclui um passo a passo em que explico todas as linhas de código.
• O código pode ser usado como base para qualquer modelo que pegue uma imagem / imagens de tamanho fixo como entrada, incluindo o insightface arcface, yolov8, detecção de face scrfd.
  • Você só precisará implementar o código de pós-processamento apropriado.
• TODO: Adicione suporte para modelos com formas dinâmicas de entrada.
• TODO: Adicione suporte para Windows

Começando

As instruções a seguir assumem que você está usando o Ubuntu 20.04 ou 22.04. Você precisará fornecer seu próprio modelo ONNX para este código de exemplo ou pode baixar o modelo de amostra (consulte a seção de verificação de sanidade abaixo).

Pré -requisitos

• Testado e trabalhando no Ubuntu 20.04 e 22.04 (o Windows não é suportado no momento)
• Instale o CUDA 11 ou 12, instruções aqui.
  • Recomendado> = 12.0
  • Necessário> = 11.0
• Instale o CUDNN, instruções aqui.
  • Necessário> = 8
  • Exigido <9 (OpenCV GPU ainda não suporta)
• sudo apt install build-essential
• sudo snap install cmake --classic
• sudo apt install libspdlog-dev libfmt-dev (para registro)
• Instale o OpenCV com suporte CUDA. Para compilar o OpenCV da fonte, execute o script build_opencv.sh fornecido em ./scripts/ .
  • Se você usa o script fornecido e instalou o CUDNN em um local fora do padrão, você deverá modificar as variáveis CUDNN_INCLUDE_DIR e CUDNN_LIBRARY no script.
  • Recomendado> = 4.8
• Faça o download do Tensorrt 10 daqui.
  • Necessário> = 10.0
• Navegue até o arquivo CMakeLists.txt e substitua o TODO pelo caminho para a instalação do Tensorrt.

Construindo a biblioteca

• mkdir build
• cd build
• cmake ..
• make -j$(nproc)

Executando o executável

• Navegue até o diretório de construção
• Execute o executável e forneça o caminho para o seu modelo ONNX.
• ex. ./run_inference_benchmark --onnx_model ../models/yolov8n.onnx
  • Nota: Consulte a seção de verificação da sanidade abaixo para obter instruções sobre como obter o modelo Yolov8n.
• Na primeira vez que você executa o executável para um determinado modelo e opções, um arquivo de mecanismo Tensorrt será criado a partir do seu modelo ONNX. Esse processo é bastante lento e pode levar mais de 5 minutos para alguns modelos (por exemplo, modelos YOLO).
• Como alternativa, você pode optar por fornecer seu próprio arquivo de mecanismo Tensorrt diretamente:
• ex. ./run_inference_benchmark --trt_model ../models/yolov8n.engine.NVIDIAGeForceRTX3080LaptopGPU.fp16.1.1
  • NOTA: Consulte V5.0 Changelog abaixo para avisos ao fornecer seu próprio arquivo de mecanismo Tensorrt.

Verificação de sanidade

• Para executar uma verificação de sanidade, faça o download do modelo YOLOv8n a partir daqui.
• Em seguida, converta -o de Pytorch em ONNX usando o seguinte script:
  • Você precisará executar pip3 install ultralytics primeiro.

 from ultralytics import YOLO
model = YOLO ( "./yolov8n.pt" )
model . fuse ()
model . info ( verbose = False )  # Print model information
model . export ( format = "onnx" , opset = 12 ) # Export the model to onnx using opset 12

• Coloque o modelo ONNX resultante, yolov8n.onnx , no diretório ./models/ .
• Executando a inferência usando o referido modelo e a imagem localizada em ./inputs/team.jpg deve produzir o seguinte vetor de recurso:
  • Nota: O vetor de recurso não será idêntico (mas muito semelhante), pois o Tensorrt não é determinístico.

 3.41113 16.5312 20.8828 29.8984 43.7266 54.9609 62.0625 65.8594 70.0312 72.9531 ...

Int8 Inferência

A ativação da precisão INT8 pode acelerar ainda mais a inferência ao custo da redução da precisão devido à faixa dinâmica reduzida. Para precisão INT8, o usuário deve fornecer dados de calibração representativos dos dados reais que o modelo verá. É recomendável usar imagens de calibração 1K+. Para ativar a inferência INT8 no modelo de verificação de sanidade Yolov8, as seguintes etapas devem ser tomadas:

• Alterar options.precision = Precision::FP16; para options.precision = Precision::INT8; em main.cpp
• options.calibrationDataDirectoryPath = ""; deve ser alterado no main.cpp para especificar o caminho contendo dados de calibração.
  • Se estiver usando o modelo YOLOV8, ele é aconselhado a usar o conjunto de dados de validação do Coco, que pode ser baixado com wget http://images.cocodataset.org/zips/val2017.zip
• Verifique se o código de redimensionamento no método Int8EntropyCalibrator2::getBatch no engine.cpp (consulte TODO ) está correto para o seu modelo.
  • Se estiver usando o modelo YOLOV8, o código de pré -processamento está correto e não precisa ser alterado.
• Recompile, execute o executável.
• O cache de calibração será gravado no disco (extensão .calibration ) para que, nas otimizações subsequentes do modelo, ele possa ser reutilizado. Se você deseja regenerar os dados de calibração, exclua este arquivo de cache.
• Se você receber um erro "fora da memória na função", deverá reduzir Options.calibrationBatchSize para que todo o lote possa caber na sua memória GPU.

Benchmarks

Os benchmarks são executados na GPU de laptop RTX 3050 TI, núcleo de 11ª geração Intel (R) (TM) I9-11900H @ 2.50GHz.

Modelo	Precisão	Tamanho do lote	Tempo de inferência AVG
Yolov8n	Fp32	1	4.732 MS
Yolov8n	FP16	1	2.493 ms
Yolov8n	Int8	1	2,009 ms
Yolov8x	Fp32	1	76,63 ms
Yolov8x	FP16	1	25,08 ms
Yolov8x	Int8	1	11.62 MS

Integração de amostra

Quer saber como integrar esta biblioteca ao seu projeto? Ou talvez como ler as saídas do modelo Yolov8 para extrair informações significativas? Nesse caso, confira meus dois projetos mais recentes, Yolov8-Tensorrt-CPP e YOLOV9-TENSORRT-CPP, que demonstram como usar a API Tensorrt C ++ para executar a inferência Yolov8/9 (suporta a detecção de objetos, a segmentação semântica e a estimativa de pose do corpo). Eles fazem uso deste projeto no back -end!

Estrutura do projeto

project-root/
├── include/
│   ├── engine/
│   │   ├── EngineRunInference.inl
│   │   ├── EngineUtilities.inl
│   │   └── EngineBuildLoadNetwork.inl
│   ├── util/...
│   ├── ...
├── src/
|   ├── ...
│   ├── engine.cpp
│   ├── engine.h
│   └── main.cpp
├── CMakeLists.txt
└── README.md

Compreendendo o código

• A maior parte da implementação está localizada em include/engine . Escrevi muitos comentários em todo o código, o que deve facilitar a compreensão do que está acontecendo.
• O código de inferência está localizado em include/engine/EngineRunInference.inl .
• O edifício e o carregamento do arquivo do motor Tensorrt está localizado include/engine/EngineBuildLoadNetwork.inl .
• Você também pode conferir meu vídeo de mergulho profundo, no qual explico todas as linhas de código.

Como depurar

• A implementação usa a biblioteca spdlog para registro. Você pode alterar o nível de log definindo a variável de ambiente LOG_LEVEL em um dos seguintes valores: trace , debug , info , warn , error , critical , off .

• Se você tiver problemas para criar o arquivo de mecanismo Tensorrt a partir do modelo ONNX, considere definir a variável de ambiente LOG_LEVEL para trace e executar novamente o aplicativo. Isso deve fornecer mais informações sobre onde exatamente o processo de construção está falhando.

Mostre sua apreciação

Se este projeto fosse útil para você, eu apreciaria se você pudesse dar uma estrela. Isso me encorajará a garantir que esteja atualizado e resolva problemas rapidamente. Eu também faço trabalho de consultoria se você precisar de ajuda mais específica. Conecte -se comigo no LinkedIn.

Colaboradores

Tetrel de loic

Thomaskleiven

Wicyn

Changelog

V6.0

• A implementação agora requer Tensorrt> = 10.0.

V5.0

• A classe Engine foi modificada para pegar um parâmetro de modelo que especifica o tipo de dados de saída de modelos. A implementação agora suporta saídas do tipo float , __half , int8_t , int32_t , bool e uint8_t .
• Adicionado suporte para carregar o arquivo do motor Tensorrt diretamente sem a necessidade de compilar a partir do modelo ONNX. Por outro lado, é altamente recomendável que você use a API fornecida para criar o arquivo do motor a partir do modelo ONNX, em vez de carregar um modelo Tensorrt diretamente. Se você optar por carregar um arquivo de modelo Tensorrt diretamente, verifique se as Options foram definidas corretamente para o seu modelo (por exemplo, se o seu modelo foi compilado para FP32, mas você tentar executar a inferência FP16, ele falhará, potencialmente sem um erro detalhado).
• Analisador de linha de comando adicionado.

V4.1

• Suporte adicionado para o tamanho fixo do lote> 1.

V4.0

• Suporte adicionado para precisão INT8.

V3.0

• A implementação foi atualizada para usar o Tensorrt 8.6 API (Ex. IExecutionContext::enqueueV3() ).
• O executável renomeou do driver para run_inference_benchmark e agora deve ser transmitido para o modelo ONNX como argumento da linha de comando.
• Removido Options.doesSupportDynamicBatchSize . Implementação agora detecta automaticamente os tamanhos de lote suportados.
• Removido Options.maxWorkspaceSize . A implementação agora não limita a memória da GPU durante as construções do modelo, permitindo que a implementação use o máximo de pool de memória disponível para camadas intermediárias.

v2.2

• Serialize o nome do modelo como parte do arquivo do motor.

V2.1

• Suporte adicionado para modelos com várias entradas. A implementação agora suporta modelos com entradas únicas, múltiplas entradas, saídas únicas, várias saídas e lote.

V2.0

• Requer que o OpenCV CUDA seja instalado. Para instalar, siga as instruções aqui.
• Options.optBatchSizes foi removido, substituído pelo Options.optBatchSize .
• Modelos de suporte com mais de uma saída única (Ex. SCRFD).
• Suporte adicionado para modelos que não suportam a inferência em lote (a primeira dimensão de entrada é fixa).
• Mais erro de verificação de erros.
• Corrigido um monte de problemas comuns que as pessoas estavam concordando com a versão original V1.0.
• Remova o espaço em branco do nome do dispositivo GPU

Colaboradores

Obrigado a essas pessoas maravilhosas (key emoji):

Este projeto segue a especificação de todos os contribuintes. Contribuições de qualquer tipo de boas -vindas!