前言
自动驾驶之心推出的 《CUDA与TensorRT部署实战课程》，链接。记录下个人学习笔记，仅供自己参考
本次课程我们来学习课程第六章—部署分类器，一起来学习 CPU 端图像预处理方法以及速度对比
课程大纲可以看下面的思维导图
0. 简述
本小节目标：学习 CPU 端 bgr2rgb + normalization + hwc2chw 等图像预处理操作以及它们的性能比较
这节课程开始我们进入第六章节—部署分类器，这个章节偏实战，为大家准备了几个案例：
- 6.0-preprocess-speed-compare
- 6.1-deploy-classification
- 6.2-deploy-classification-advanced
- 6.3-int8-calibration
- 6.4-trt-engine-inspector
第六章节准备的案例一共是五个，第一个是 preprocess-speed-compare，这个小节主要教大家如果用 CPU 做图像预处理都有哪些方法，哪种方法访问图像速度更快；6.1 小节主要给大家介绍初步的分类器部署该怎么做，这个小节为了方便大家理解整个代码写得比较简单，也没有涉及到任何 C++ 的设计模式，所以整个代码看起来有很多缺陷；6.2 小节是针对 6.1 小节的一个扩展，主要是把 6.1 小节中的很多问题给解决掉，另外我们自己在写推理框架的时候应该考虑哪些东西
6.3 小节给大家介绍 int8 calibration，我们在前面或多或少都有涉及到量化这个概念，其中校准是量化的一个重要环节，校准包括很多校准器比如 MinMaxCalibrator、EntropyCalibrator、LegacyCalibrator 等等，我们在部署时该如何使用这些校准器呢？选择哪个校准器呢？这都是我们在 6.3 小节需要讨论的问题；最后 6.4 小节主要给大家介绍 TensorRT 官方工具 trt-engine-explorer，这个工具主要是帮助大家观察经过 TensorRT 优化前后的推理引擎在架构上有什么不同，去理解 TensorRT 做了哪些优化，哪些层融合了，哪些节点添加了，哪些节点被删除了，这个方便我们更好的去理解 TensorRT 的优化，同时可以帮助我们分析 TensorRT 中哪些优化是可以进一步改善的
后续的一些案例主要是讲 Transformer 的一些部署以及面临的一些问题，比如 attention 计算瓶颈，LayerNormalization 这种节点和 CNN 中 Conv 这种节点相比推理性能差异又在哪里，还有纯 Transformer 模型和纯 CNN 模型以及 CNN+Transformer 模型相比它们的计算效率以及计算密度有什么不同（目前 2024/8/17 尚未更新）
下面我们开始本次课程的学习🤗
1. 案例运行
在正式开始课程之前，博主先带大家跑通 6.0-preprocess-speed-compare 这个小节的案例🤗
首先大家需要把 tensorrt_starter 这个项目给 clone 下来，指令如下：
git clone https://github.com/kalfazed/tensorrt_starter.git
也可手动点击下载，点击右上角的 Code 按键，将代码下载下来。至此整个项目就已经准备好了。也可以点击 here 下载博主准备好的源代码（注意代码下载于 2024/7/14 日，若有改动请参考最新）
整个项目后续需要使用的软件主要有 CUDA、cuDNN、TensorRT、OpenCV，大家可以参考 Ubuntu20.04软件安装大全 进行相应软件的安装，博主这里不再赘述
假设你的项目、环境准备完成，下面我们一起来运行下 6.0-preprocess-speed-compare 小节案例代码
我们需要修改下整体的 Makefile.config，指定一些库的路径：
# tensorrt_starter/config/Makefile.config
# CUDA_VER := 11
CUDA_VER := 11.6
# opencv和TensorRT的安装目录
OPENCV_INSTALL_DIR := /usr/local/include/opencv4
# TENSORRT_INSTALL_DIR := /mnt/packages/TensorRT-8.4.1.5
TENSORRT_INSTALL_DIR := /home/jarvis/lean/TensorRT-8.6.1.6
Note：大家查看自己的 CUDA 是多少版本，修改为对应版本即可，另外 OpenCV 和 TensorRT 修改为你自己安装的路径即可
接着我们就可以来执行编译，指令如下：
make -j64
输出如下：
接着执行：
./bin/trt-infer
输出如下：
我们这里对比了 CPU 端进行 bgr2rgb+norm+hwc2chw 预处理的五种不同方法执行的速度对比，在终端可以看到各个方法处理的时间，另外在 data 文件夹下保存着处理后的图片，如下所示：
Note：博主的 CPU 是 12th Gen Intel® Core™ i5-12400F，每次执行结果都不一样会有波动这个很正常，不同 CPU 测量出来的结果可能会有差异，另外图像分辨率不同时间也会有差异
如果大家能够看到上述输出结果，那就说明本小节案例已经跑通，下面我们就来看看具体的代码实现
2. 代码分析
2.1 main.cpp
我们先从 main.cpp 看起：
#include <iostream>
#include <memory>
#include "model.hpp"
#include "utils.hpp"
#include "timer.hpp"
#include "preprocess.hpp"
using namespace std;
void bgr2rgb_cpu_speed_test(){
Timer timer;
string imagePath = "data/fox.png";
string savePath = "";
cv::Mat src = cv::imread(imagePath);
cv::Mat tar(src.rows, src.cols, CV_8UC3);
LOG("Starting cpu bgr2rgb speed test...");
timer.start_cpu();
preprocess_cv_cvtcolor(src, tar);
timer.stop_cpu();
timer.duration_cpu<Timer::ms>("Using cv::cvtcolor takes");
savePath = "data/fox-cvtcolor.png";
cv::imwrite(savePath, tar);
timer.start_cpu();
preprocess_cv_mat_at(src, tar);
timer.stop_cpu();
timer.duration_cpu<Timer::ms>("Using cv::Mat::at takes");
savePath = "data/fox-mat-at.png";
cv::imwrite(savePath, tar);
timer.start_cpu();
preprocess_cv_mat_iterator(src, tar);
timer.stop_cpu();
timer.duration_cpu<Timer::ms>("Using cv::MatIterator_ takes");
savePath = "data/fox-mat-iterator.png";
cv::imwrite(savePath, tar);
timer.start_cpu();
preprocess_cv_mat_data(src, tar);
timer.stop_cpu();
timer.duration_cpu<Timer::ms>("Using cv::Mat data takes");
savePath = "data/fox-mat-data.png";
cv::imwrite(savePath, tar);
timer.start_cpu();
preprocess_cv_pointer(src, tar);
timer.stop_cpu();
timer.duration_cpu<Timer::ms>("Using pointer takes");
savePath = "data/fox-pointer.png";
cv::imwrite(savePath, tar);
}
void bgr2rgb_norm_hwc2chw_cpu_speed_test(){
Timer timer;
string imagePath = "data/fox.png";
cv::Mat src = cv::imread(imagePath);
int size = src.cols * src.rows * src.channels();
float* tar = (float*)malloc(size * sizeof(float));
int width = 224;
int height = 224;
int channel = 3;
int classes = 1000;
float mean[3] = {0.406, 0.456, 0.485};
float std[3] = {0.225, 0.224, 0.229};
cv::resize(src, src, cv::Size(width, height));
LOG("Starting cpu bgr2rgb + normalization + hwc2chw speed test...");
timer.start_cpu();
preprocess_cv_mat_at(src, tar, mean, std);
timer.stop_cpu();
timer.duration_cpu<Timer::ms>("Using cv::Mat::at takes");
timer.start_cpu();
preprocess_cv_mat_iterator(src, tar, mean, std);
timer.stop_cpu();
timer.duration_cpu<Timer::ms>("Using cv::MatIterator_ takes");
timer.start_cpu();
preprocess_cv_mat_data(src, tar, mean, std);
timer.stop_cpu();
timer.duration_cpu<Timer::ms>("Using cv::Mat data takes");
timer.start_cpu();
preprocess_cv_pointer(src, tar, mean, std);
timer.stop_cpu();
timer.duration_cpu<Timer::ms>("Using pointer takes");
timer.start_cpu();
preprocess_cv_array(src, tar, mean, std);
timer.stop_cpu();
timer.duration_cpu<Timer::ms>("Using array takes");
}
int main(int argc, char const *argv[])
{
// bgr2rgb_cpu_speed_test();
bgr2rgb_norm_hwc2chw_cpu_speed_test();
}
上述代码主要用于测试不同方法在 OpenCV 中进行图像预处理操作时的速度，主要有 bgr2rgb_cpu_speed_test() 和 bgr2rgb_norm_hwc2chw_cpu_speed_test() 两个函数，它们分别测量了不同方法在特定预处理操作中的耗时情况
bgr2rgb_cpu_speed_test() 函数
- 该函数测试了使用不同方法将图像从 BGR 色彩空间转换为 RGB 色彩空间的速度
preprocess_cv_cvtcolor()方法- 使用
cv::cvtColor函数将图像从 BGR 转换为 RGB
- 使用
preprocess_cv_mat_at()方法- 使用
cv::Mat::at方法逐元素访问并修改图像
- 使用
preprocess_cv_mat_iterator()方法- 使用
cv::MatIterator_遍历图像矩阵
- 使用
preprocess_cv_mat_data()方法- 直接通过指针访问图像数据
preprocess_cv_pointer()方法- 手动通过指针运算来访问和修改元素
bgr2rgb_norm_hwc2chw_cpu_speed_test() 函数
- 该函数测试了进行 BGR 到 RGB 转换、归一化以及 HWC 到 CHW 转换组合操作的速度
preprocess_cv_mat_at()方法- 使用
cv::Mat::at方式访问和处理像素
- 使用
preprocess_cv_mat_iterator()方法- 使用
cv::MatIterator_进行像素处理
- 使用
preprocess_cv_mat_data()方法- 通过指针直接访问图像数据进行处理
preprocess_cv_pointer()方法- 使用手动指针运算
在 main.cpp 中我们实现了一个初步的在 CPU 端的前处理的性能比较，比较的是对于访问 CV::Mat 的数据，哪一种方式会比较快。因为有的时候我们可能会考虑在 CPU 上做前处理，比如说图像前处理放在 GPU 上时并不能充分把硬件资源吃满，导致硬件资源浪费，如果出现这种情况的话，我们可能会考虑把前处理放在 CPU 上，而把 DNN 的 forward 部分放在 GPU 上进行异步的推理
这里主要比较四种方法：
- 使用
cv::Mat::at - 使用
cv::MatIterator_ - 使用
cv::Mat.data - 使用
cv::Mat.ptr
同时我们在 main.cpp 中也比较了一下 CPU 端做 bgr2rgb 和 bgr2rgb + normalization + hwc2chw 的性能比较
2.2 preprocess.cpp
下面我们一起来看具体的函数实现，我们先从 bgr2rgb 函数中的方法实现看起
preprocess_cv_cvtcolor() 方法具体实现代码如下：
void preprocess_cv_cvtcolor(cv::Mat src, cv::Mat tar){
cv::cvtColor(src, tar, cv::COLOR_RGB2BGR);
}
该方法非常的简单，主要是利用 OpenCV 提供的 cv::cvtColor 函数来完成从 RGB 到 BGR 色彩空间的转换
preprocess_cv_mat_at() 方法具体实现代码如下：
void preprocess_cv_mat_at(cv::Mat src, cv::Mat tar){
for (int i = 0; i < src.rows; i++) {
for (int j = 0; j < src.cols; j++) {
tar.at<cv::Vec3b>(i, j)[2] = src.at<cv::Vec3b>(i, j)[0];
tar.at<cv::Vec3b>(i, j)[1] = src.at<cv::Vec3b>(i, j)[1];
tar.at<cv::Vec3b>(i, j)[0] = src.at<cv::Vec3b>(i, j)[2];
}
}
}
该方法通过双重循环遍历图像中的每一个像素，外层循环遍历图像每一行，内层循环遍历图像每一列，接着通过 .at<cv::Vec3b> 访问目标图像和源图像中的每一个像素并进行相应的通道转换，其中 cv::Vec3b 表示一个包含三个 uchar 值的向量即一个像素，它对应 BGR 三个通道的值
这种方法的优点在于直接访问和操作，可以允许你精确地控制每个像素地操作，在需要对像素级别进行复杂的自定义操作时非常有用，但是它的速度较慢，当图像较大时这种方法的效率会成为一个瓶颈
preprocess_cv_mat_iterator() 方法具体实现代码如下：
void preprocess_cv_mat_iterator(cv::Mat src, cv::Mat tar){
cv::MatIterator_<cv::Vec3b> src_it = src.begin<cv::Vec3b>();
cv::MatIterator_<cv::Vec3b> tar_it = tar.begin<cv::Vec3b>();
cv::MatIterator_<cv::Vec3b> end = src.end<cv::Vec3b>();
for (; src_it != end; src_it++, tar_it++) {
(*tar_it)[2] = (*src_it)[0];
(*tar_it)[1] = (*src_it)[1];
(*tar_it)[0] = (*src_it)[2];
}
}
该方法利用 OpenCV 提供的 cv::MatIterator_ 迭代器来遍历和操作图像的每个像素，相较于 cv::Mat::at 方法，迭代器提供了一种更直接的方式来遍历矩阵，并且在某些情况下可以提高代码的执行效率。首先我们初始化三个迭代器，其中 src_it 指向源图像的起始位置，tar_it 指向目标图像的起始位置，end 指向源图像的结束位置，接着我们进行迭代循环和转换操作
该方法使用迭代器的方式使得代码更加简洁，并且迭代器的运算通常比 cv::Mat::at 更加高效，但是它的性能未必最佳，对于需要更高性能的场景直接操作指针或 cv::Mat::data 可能更合适
preprocess_cv_mat_data() 方法具体实现如下：
void preprocess_cv_mat_data(cv::Mat src, cv::Mat tar){
int height = src.rows;
int width = src.cols;
int channels = src.channels();
for (int i = 0; i < height; i ++) {
for (int j = 0; j < width; j ++) {
int index = i * width * channels + j * channels;
tar.data[index + 2] = src.data[index + 0];
tar.data[index + 1] = src.data[index + 1];
tar.data[index + 0] = src.data[index + 2];
}
}
}
该方法直接使用指针访问图像数据，逐个像素进行 BGR 到 RGB 的转换，相比于之前的方法，这种方式更加接近底层操作，能够提高更高的性能，但代码的可读性相对较低
首先外层循环遍历图像的每一行，内层循环遍历图像的每一列，接着计算像素索引，通过像素索引去访问每一个像素从而实现颜色通道交换。其中 src.data 和 tar.data 都是一个 uchar* 类型的指针，指向图像数据在内存中的起始位置，通过直接操作这个指针，可以访问和修改图像的原始数据
preprocess_cv_pointer() 方法具体实现如下：
void preprocess_cv_pointer(cv::Mat src, cv::Mat tar){
for (int i = 0; i < src.rows; i ++) {
cv::Vec3b* src_ptr = src.ptr<cv::Vec3b>(i);
cv::Vec3b* tar_ptr = tar.ptr<cv::Vec3b>(i);
for (int j = 0; j < src.cols; j ++) {
tar_ptr[j][2] = src_ptr[j][0];
tar_ptr[j][1] = src_ptr[j][1];
tar_ptr[j][0] = src_ptr[j][2];
}
}
}
该方法通过使用指针来遍历和操作图像的每个像素进行 BGR 到 RGB 的颜色变换，相比直接访问图像数据，这种方法利用了指针的优势，同时保持了相对较好的可读性和操作的灵活性
首先我们逐行指针操作，外层循环遍历图像的每一行，接着进行行指针初始化，然后我们逐列操作，内存循环遍历图像的每一列，此时通过指针 src_ptr[i] 和 tar_ptr[j] 可以直接访问和操作每个像素
我们执行下看下输出如下所示：
我们从图中可以看到速度最快的是最后两个使用指针操作的方法，相比之下直接使用 cv::cvtColor 方法耗时最严重
Note：博主每次执行的结果都不尽相同，但是总的来说使用指针操作的方法是速度最快的，大家以自己实际的 CPU 执行结果为准就行
下面我们来看 bgr2rgb_norm_hwc2chw 函数的实现，那大部分其实和 bgr2rgb 的方法差不多，只是添加了一个 normalization 以及 hwc2chw 操作，这里我们就简单过一下
preprocess_cv_mat_at() 方法具体实现如下：
void preprocess_cv_mat_at(cv::Mat src, float* tar, float* mean, float* std){
float* ptar_ch0 = tar + src.rows * src.cols * 0;
float* ptar_ch1 = tar + src.rows * src.cols * 1;
float* ptar_ch2 = tar + src.rows * src.cols * 2;
for (int i = 0; i < src.rows; i++) {
for (int j = 0; j < src.cols; j++) {
(*ptar_ch2++) = (src.at<cv::Vec3b>(i, j)[0] / 255.0f - mean[0]) / std[0];
(*ptar_ch1++) = (src.at<cv::Vec3b>(i, j)[1] / 255.0f - mean[1]) / std[1];
(*ptar_ch0++) = (src.at<cv::Vec3b>(i, j)[2] / 255.0f - mean[2]) / std[2];
}
}
}
该方法首先初始化目标指针，其中 ptar_ch0、ptar_ch1、ptar_ch2 分别指向目标数组 tar 中 R、G、B 三个通道的起始位置，这种布局方式确保图像数据在内存中按通道顺序存储，而不是按像素顺序存储，即 CHW 格式。接着双重循环遍历图像中的每个像素，外层循环遍历图像的每一行，内存循环遍历图像的每一列，最后进行颜色空间转换和归一化
preprocess_cv_mat_iterator() 方法具体实现如下：
void preprocess_cv_mat_iterator(cv::Mat src, float* tar, float* mean, float* std){
float* ptar_ch0 = tar + src.rows * src.cols * 0;
float* ptar_ch1 = tar + src.rows * src.cols * 1;
float* ptar_ch2 = tar + src.rows * src.cols * 2;
cv::MatIterator_<cv::Vec3b> it = src.begin<cv::Vec3b>();
cv::MatIterator_<cv::Vec3b> end = src.end<cv::Vec3b>();
for (; it != end; it++) {
(*ptar_ch2++) = ((*it)[0] / 255.0f - mean[0]) / std[0];
(*ptar_ch1++) = ((*it)[1] / 255.0f - mean[1]) / std[1];
(*ptar_ch0++) = ((*it)[2] / 255.0f - mean[2]) / std[2];
}
}
该方法使用迭代器 cv::MatIterator_ 来遍历图像数据，并在遍历过程中完成图像数据的 BGR 到 RGB 转换、归一化操作以及 HWC 到 CHW 格式的转换
preprocess_cv_mat_data() 方法具体实现如下：
void preprocess_cv_mat_data(cv::Mat src, float* tar, float* mean, float* std){
float* ptar_ch0 = tar + src.rows * src.cols * 0;
float* ptar_ch1 = tar + src.rows * src.cols * 1;
float* ptar_ch2 = tar + src.rows * src.cols * 2;
int height = src.rows;
int width = src.cols;
int channels = src.channels();
for (int i = 0; i < height; i ++) {
for (int j = 0; j < width; j ++) {
int index = i * width * channels + j * channels;
(*ptar_ch2++) = (src.data[index + 0] / 255.0f - mean[0]) / std[0];
(*ptar_ch1++) = (src.data[index + 1] / 255.0f - mean[1]) / std[1];
(*ptar_ch0++) = (src.data[index + 2] / 255.0f - mean[2]) / std[2];
}
}
}
该方法直接操作图像的内存数据，通过计算每个像素在内存中的索引来进行 BGR 到 RGB 的转换、归一化处理以及从 HWC 到 CHW 格式的转换，相比于使用迭代器或 cv::Mat::at 方法，这种方法更加接近底层，通常在性能上更有优势
preprocess_cv_pointer() 方法具体实现如下：
void preprocess_cv_pointer(cv::Mat src, float* tar, float* mean, float* std){
int area = src.rows * src.cols;
int offset_ch0 = area * 0;
int offset_ch1 = area * 1;
int offset_ch2 = area * 2;
for (int i = 0; i < src.rows; i ++) {
cv::Vec3b* src_ptr = src.ptr<cv::Vec3b>(i);
for (int j = 0; j < src.cols; j ++) {
tar[offset_ch2++] = (src_ptr[j][0] / 255.0f - mean[0]) / std[0];
tar[offset_ch1++] = (src_ptr[j][1] / 255.0f - mean[1]) / std[1];
tar[offset_ch0++] = (src_ptr[j][2] / 255.0f - mean[2]) / std[2];
}
}
}
该方法同时使用指针来访问和处理图像数据，完成 BGR 到 RGB 的颜色空间转换、归一化处理以及从 HWC 到 CHW 格式的转换，这种方法结合了指针的高效性，通常在性能上有不错的表现
我们执行下看下输出如下所示：
我们从图中可以看到速度最快的依旧是指针操作的方法，速度最慢的是逐像素访问的方法
Note：博主每次执行的结果都不尽相同，但是总的来说使用指针操作的方法是速度最快的，大家以自己实际的 CPU 执行结果为准就行
3. 补充说明
值得注意的是这个小节的 Makefile 也有一些改动，主要体现在 bear 工具的使用，如下所示：
ifeq (, $(shell which bear))
BEARCMD :=
else
ifeq (bear 3.0.18, $(shell bear --version))
BEARCMD := bear --output config/compile_commands.json --
else
BEARCMD := bear -o config/compile_commands.json
endif
endif
我们前面有提到过 bear 是一个用于生成 compile_commands.json 文件的工具，这个文件通常用于启用基于 clangd 或其他类似工具的代码分析和自动补全功能。bear 工具会拦截编译命令并记录它们，从而生成描述如何构建项目中每个源文件的 JSON 数据
另外在不同的 Ubuntu 系统中，bear 的指令可能有所不同，这个主要取决于安装的 bear 版本，在最新的 Ubuntu22.04 系统中推荐使用的 bear 版本是 3.0.18，比较老的 Ubuntu18.04 和 Ubuntu20.04 推荐使用的 bear 版本是 2.6 或者 2.7
关于 bear 的安装我们可以直接通过 apt-get 安装，指令如下：
sudo apt-get update
sudo apt-get install bear
当然我们也可以从源码编译安装，指令如下：
git clone https://github.com/rizsotto/Bear.git
cd Bear
git checkout tags/3.0.18
mkdir build && cd build
cmake .. && make
sudo make install
结语
本次课程我们学习了 CPU 端图像预处理的几种方法，包括逐像素方法，迭代器方法以及指针方法，其中指针方法耗时最慢，速度最快。当我们处理的图像较小在 GPU 端计算密度不高时我们可以采用这个小节所说的几种在 CPU 端处理的方法
OK，以上就是 6.0 小节案例的全部内容了，下节我们来学习 6.1 小节分类器的简单部署实现，敬请期待😄
扫一扫
881
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
