Descarga de tensorrt cpp api - Descargar código fuente tensorrt cpp api

tensorrt cpp api

C/C++

1.0.0

Descargar

logo

Tutorial de API Tensorrt C ++

Cómo usar la API Tensorrt C ++ para una inferencia de aprendizaje automático GPU de alto rendimiento.
Admite modelos con entradas simples / múltiples y salidas simples / múltiples con lotes.

Video de descripción general del proyecto. Código de video de inmersión profunda

Buscando mantenedores

Este proyecto está buscando activamente mantenedores para ayudar a guiar su crecimiento y mejora. Si te apasiona este proyecto e interesado en contribuir, ¡me encantaría saber de ti!

No dude en comunicarse con LinkedIn para discutir cómo puede involucrarse.

Tensorrt C ++ Tutorial

¡Leí todos los documentos Nvidia Tensorrt para que no tengas que hacerlo!

Este proyecto demuestra cómo usar la API Tensorrt C ++ para la inferencia de GPU de alto rendimiento en los datos de la imagen. Cubre cómo hacer lo siguiente:

Cómo instalar Tensorrt 10 en Ubuntu 20.04 / 22.04.
Cómo generar un archivo de motor Tensorrt optimizado para su GPU.
Cómo especificar un perfil de optimización simple.
Cómo ejecutar la inferencia de precisión FP32, FP16 o Int8.
Cómo leer / escribir datos desde / en la memoria de GPU y trabajar con imágenes de GPU.
Cómo usar la transmisión CUDA para ejecutar la inferencia de asíncrono y luego sincronizar.
Cómo trabajar con modelos con tamaños de lotes estáticos y dinámicos.
Cómo trabajar con modelos con tensores de salida simples o múltiples.
Cómo trabajar con modelos con múltiples entradas.
Incluye un tutorial de video donde explico cada línea de código.
El código se puede utilizar como base para cualquier modelo que tome una imagen / imágenes de tamaño fijo como entrada, incluidas Insightface Arcface, Yolov8, detección de cara SCRFD.
- Solo necesitará implementar el código de postprocesamiento apropiado.
TODO: Agregue soporte para modelos con formas de entrada dinámica.
TODO: Agregar soporte para Windows

Empezando

Las siguientes instrucciones suponen que está utilizando Ubuntu 20.04 o 22.04. Deberá suministrar su propio modelo ONNX para este código de muestra o puede descargar el modelo de muestra (consulte la sección Verificación de cordura a continuación).

Requisitos previos

Probado y trabajando en Ubuntu 20.04 y 22.04 (Windows no es compatible en este momento)
Instale CUDA 11 o 12, instrucciones aquí.
- Recomendado> = 12.0
- Requerido> = 11.0
Instale Cudnn, instrucciones aquí.
- Requerido> = 8
- Requerido <9 (OpenCV GPU aún no es compatible)
sudo apt install build-essential
sudo snap install cmake --classic
sudo apt install libspdlog-dev libfmt-dev (para registro)
Instale OpenCV con soporte CUDA. Para compilar OpenCV desde la fuente, ejecute el script build_opencv.sh proporcionado en ./scripts/ .
- Si usa el script proporcionado y ha instalado CUDNN en una ubicación no estándar, debe modificar las variables CUDNN_INCLUDE_DIR y CUDNN_LIBRARY en el script.
- Recomendado> = 4.8
Descargue Tensorrt 10 desde aquí.
- Requerido> = 10.0
Navegue al archivo CMakeLists.txt y reemplace el TODO con la ruta a su instalación de Tensorrt.

Construyendo la biblioteca

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

Ejecutando el ejecutable

Navegue al directorio de compilación
Ejecute el ejecutable y proporcione la ruta a su modelo ONNX.
ex. ./run_inference_benchmark --onnx_model ../models/yolov8n.onnx
- Nota: Consulte la sección Verificación de cordura a continuación para obtener instrucciones sobre cómo obtener el modelo Yolov8N.
La primera vez que ejecute el ejecutable para un modelo y opciones determinadas, se construirá un archivo de motor Tensorrt a partir de su modelo ONNX. Este proceso es bastante lento y puede tardar más de 5 minutos para algunos modelos (ex. Modelos Yolo).
Alternativamente, puede elegir suministrar su propio archivo de motor Tensorrt directamente:
ex. ./run_inference_benchmark --trt_model ../models/yolov8n.engine.NVIDIAGeForceRTX3080LaptopGPU.fp16.1.1
- Nota: Consulte V5.0 ChangeLog a continuación para obtener advertencias cuando proporcione su propio archivo de motor Tensorrt.

Cheque de cordura

Para realizar una verificación de cordura, descargue el modelo YOLOv8n desde aquí.
A continuación, conviértalo de Pytorch a ONNX usando el siguiente script:
- Primero deberá ejecutar pip3 install ultralytics .

 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 el modelo ONNX resultante, yolov8n.onnx , en el directorio ./models/ .
Ejecutar inferencia utilizando dicho modelo y la imagen ubicada en ./inputs/team.jpg debería producir el siguiente vector de características:
- Nota: El vector de características no será idéntico (pero muy similar) ya que Tensorrt no es determinista.

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

Inferencia int8

Habilitar la precisión INT8 puede acelerar aún más la inferencia a costa de la reducción de la precisión debido al rango dinámico reducido. Para la precisión int8, el usuario debe suministrar datos de calibración que sean representativos de los datos reales que el modelo verá. Se recomienda usar imágenes de calibración 1K+. Para habilitar la inferencia INT8 con el modelo de verificación de cordura Yolov8, se deben tomar los siguientes pasos:

Cambiar options.precision = Precision::FP16; a options.precision = Precision::INT8; en main.cpp
options.calibrationDataDirectoryPath = ""; debe cambiarse en main.cpp para especificar la ruta que contiene datos de calibración.
- Si usa el modelo YOLOV8, se recomienda utilizar el conjunto de datos de validación de Coco, que se puede descargar con wget http://images.cocodataset.org/zips/val2017.zip
Asegúrese de que el código de cambio de tamaño en el método Int8EntropyCalibrator2::getBatch en engine.cpp (ver TODO ) sea correcto para su modelo.
- Si usa el modelo YOLOV8, el código de preprocesamiento es correcto y no es necesario cambiar.
Recompire, ejecute el ejecutable.
El caché de calibración se escribirá en el disco (extensión .calibration ) de modo que en las optimizaciones posteriores del modelo se pueda reutilizar. Si desea regenerar los datos de calibración, debe eliminar este archivo de caché.
Si obtiene un error de "Function asignal", entonces debe reducir Options.calibrationBatchSize para que todo el lote pueda caber en la memoria de su GPU.

Puntos de referencia

Los puntos de referencia se ejecutan en RTX 3050 Ti Laptop GPU, 11th Gen Intel (R) Core (TM) I9-11900H @ 2.50 GHz.

Modelo	Precisión	Tamaño por lotes	Tiempo de inferencia 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

Integración de muestra

¿Se pregunta cómo integrar esta biblioteca en su proyecto? ¿O tal vez cómo leer las salidas del modelo Yolov8 para extraer información significativa? Si es así, consulte mis dos últimos proyectos, YOLOV8-TENSORRT-CPP y YOLOV9-TENSORRT-CPP, que demuestran cómo usar la API Tensorrt C ++ para ejecutar la inferencia Yolov8/9 (admite la detección de objetos, la segmentación semántica y la estimación de pose del cuerpo). ¡Hacen uso de este proyecto en el backend!

Estructura de proyectos

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

Comprender el código

La mayor parte de la implementación se encuentra en include/engine . He escrito muchos comentarios durante todo el código que debería facilitar la comprensión de lo que está sucediendo.
El código de inferencia se encuentra en include/engine/EngineRunInference.inl .
La construcción y la carga del archivo de motor Tensorrt se encuentra en include/engine/EngineBuildLoadNetwork.inl .
También puede ver mi video de profundidad en el que explico cada línea de código.

Cómo depurar

La implementación utiliza la biblioteca spdlog para registrar. Puede cambiar el nivel de registro estableciendo la variable de entorno LOG_LEVEL a uno de los siguientes valores: trace , debug , info , warn , error , critical , off .
Si tiene problemas para crear el archivo de motor Tensorrt desde el modelo ONNX, considere configurar la variable de entorno LOG_LEVEL para trace y volver a ejecutar la aplicación. Esto debería darle más información sobre dónde está fallando exactamente el proceso de compilación.

Muestra tu agradecimiento

Si este proyecto fuera útil para usted, agradecería si pudiera darle una estrella. Eso me animará a asegurarme de que esté actualizado y resolver problemas rápidamente. También hago trabajo de consultoría si necesita ayuda más específica. Conéctese conmigo en LinkedIn.

Colaboradores

_{Tétrel de loico}

_{Thomaskleiven}

_Wicyn

Colegio de cambios

V6.0

La implementación ahora requiere tensorrt> = 10.0.

V5.0

La clase Engine se ha modificado para tomar un parámetro de plantilla que especifica el tipo de datos de salida de los modelos. La implementación ahora admite salidas de tipo float , __half , int8_t , int32_t , bool y uint8_t .
Se agregó soporte para cargar el archivo del motor Tensorrt directamente sin necesidad de compilar del modelo ONNX. Sin embargo, se recomienda encarecidamente que use la API proporcionada para construir el archivo del motor del modelo ONNX, en lugar de cargar un modelo Tensorrt directamente. Si elige cargar un archivo de modelo Tensorrt directamente, debe verificar a mano que las Options se han configurado correctamente para su modelo (por ejemplo, si su modelo se ha compilado para FP32 pero intenta ejecutar una inferencia FP16, fallará, potencialmente sin un error verboso).
Se agregó un analizador de línea de comandos.

V4.1

Soporte agregado para el tamaño de lote fijo> 1.

V4.0

Soporte agregado para la precisión int8.

V3.0

La implementación se ha actualizado para usar Tensorrt 8.6 API (ex. IExecutionContext::enqueueV3() ).
Ejecutable ha cambiado el nombre del driver a run_inference_benchmark y ahora debe pasar la ruta al modelo ONNX como argumento de línea de comandos.
Options.doesSupportDynamicBatchSize eliminadas. Implementación ahora Auto detects tamaños de lotes admitidos.
Options.maxWorkspaceSize eliminadas. MaxworkSpacesize. La implementación ahora no limita la memoria de GPU durante las construcciones del modelo, lo que permite que la implementación use la mayor parte del grupo de memoria como esté disponible para capas intermedias.

v2.2

Serializa el nombre del modelo como parte del archivo del motor.

V2.1

Se agregó soporte para modelos con múltiples entradas. La implementación ahora admite modelos con entradas únicas, múltiples entradas, salidas únicas, salidas múltiples y lotes.

V2.0

Requiere que OpenCV CUDA se instale. Para instalar, siga las instrucciones aquí.
Options.optBatchSizes se ha eliminado, reemplazado por Options.optBatchSize .
Modelos de soporte con más de una sola salida (ex. SCRFD).
Soporte agregado para modelos que no admiten la inferencia por lotes (la primera dimensión de entrada es fija).
Más verificación de errores.
Se corrigió un montón de problemas comunes con los que se encontraba la gente con la versión original V1.0.
Eliminar el espacio en blanco del nombre del dispositivo GPU