200 lines
9.7 KiB
Plaintext
200 lines
9.7 KiB
Plaintext
#include "retinanet_classify_inference.h"
|
||
|
||
RetinanetClassifyInference::RetinanetClassifyInference() {}
|
||
|
||
RetinanetClassifyInference::~RetinanetClassifyInference() {}
|
||
|
||
|
||
int RetinanetClassifyInference::RetinanetClassifyInferenceInit(ModelInfo* pRetinanetClassifyModelInfo, const std::string& strModelName, const std::string& strDeployName, const std::string& strEngineName)
|
||
{
|
||
pRetinanetClassifyModelInfo_ = pRetinanetClassifyModelInfo;
|
||
|
||
//资源分配(创建流,host及device侧内存)
|
||
cudaSetDevice(DEVICE); //设置GPU
|
||
|
||
//创建图像预处理CUDA流
|
||
pImagePreprocessStream_ = new cudaStream_t;
|
||
CUDA_CHECK(cudaStreamCreate(pImagePreprocessStream_));
|
||
|
||
//创建模型推理CUDA流
|
||
pInferenceModelStream_ = new cudaStream_t;
|
||
CUDA_CHECK(cudaStreamCreate(pInferenceModelStream_));
|
||
|
||
pGLogger_ = new Logger;
|
||
|
||
//相关资源分配
|
||
pfBuffers_[0] = nullptr; pfBuffers_[1] = nullptr;
|
||
CUDA_CHECK(cudaMalloc((void**)&pfBuffers_[0], pRetinanetClassifyModelInfo_->uiInputSize * sizeof(float))); //输入资源分配
|
||
CUDA_CHECK(cudaMalloc((void**)&pfBuffers_[1], pRetinanetClassifyModelInfo_->uiOutputSize * sizeof(float))); //输出资源分配
|
||
|
||
pu8ImgHost_ = new uint8_t;
|
||
pu8ImgDevice_ = new uint8_t;
|
||
|
||
CUDA_CHECK(cudaMallocHost((void**)&pu8ImgHost_, MAX_IMAGE_INPUT_SIZE_THRESH * pRetinanetClassifyModelInfo_->uiChannel)); //在HOST侧申请预处理数据缓存
|
||
CUDA_CHECK(cudaMalloc((void**)&pu8ImgDevice_, MAX_IMAGE_INPUT_SIZE_THRESH * pRetinanetClassifyModelInfo_->uiChannel)); //在DEVICE侧申请预处理数据缓存
|
||
|
||
pfInputData_ = new float[pRetinanetClassifyModelInfo_->uiBatchSize * pRetinanetClassifyModelInfo_->uiInputSize];
|
||
pfOutputData_ = new float[pRetinanetClassifyModelInfo_->uiBatchSize * pRetinanetClassifyModelInfo_->uiOutputSize];
|
||
|
||
//序列化引擎
|
||
//直接使用API创建一个模型，并将其序列化为流 编译成TensorRT引擎engine文件后无需再次调用,调用依次生成engine即可
|
||
//基于caffe解析器编译tensorrt引擎
|
||
#if 0
|
||
std::vector<std::string> vecOutputs = {pRetinanetClassifyModelInfo_->strOutputBlobName};
|
||
if (!strModelName.empty() && !strDeployName.empty()) {
|
||
IHostMemory* modelStream{ nullptr };
|
||
CaffeToModel(*pGLogger_, pRetinanetClassifyModelInfo_->uiBatchSize, MAX_WORKSPAXE_SIZE, &modelStream, strModelName, strDeployName, vecOutputs);
|
||
assert(modelStream != nullptr);
|
||
std::ofstream p(strEngineName, std::ios::binary);
|
||
if (!p) {
|
||
std::cerr << "could not open plan output file" << std::endl;
|
||
return -1;
|
||
}
|
||
p.write(reinterpret_cast<const char*>(modelStream->data()), modelStream->size());
|
||
modelStream->destroy();
|
||
}
|
||
#endif
|
||
|
||
//反序列化模型并运行推理
|
||
std::ifstream file(strEngineName, std::ios::binary);
|
||
if (!file.good()) {
|
||
std::cerr << "read " << strEngineName << " error!" << std::endl;
|
||
return -1;
|
||
}
|
||
|
||
//创建tensorRT流对象trtModelStream,这个就跟文件流中的ifstream类似的
|
||
//trtModelStream是一块内存区域,用于保存序列化的plan文件
|
||
char *trtModelStream = nullptr;
|
||
size_t size = 0;
|
||
file.seekg(0, file.end); //将指针移动至距离文件末尾0处的位置
|
||
size = file.tellg(); //获得当前字符的位置
|
||
file.seekg(0, file.beg); //将指针移动至距离文件开头0处的位置
|
||
trtModelStream = new char[size];
|
||
assert(trtModelStream);
|
||
file.read(trtModelStream, size); //将序列化engine模型(数据及数据大小)读入trtModelStream
|
||
file.close();
|
||
|
||
//1.设置运行时环境
|
||
pRuntime_ = createInferRuntime(*pGLogger_); //创建运行时环境IRuntime对象,传入gLogger用于打印信息
|
||
assert(pRuntime_ != nullptr);
|
||
//2.生成反序列化引擎
|
||
pEngine_ = pRuntime_->deserializeCudaEngine(trtModelStream, size); //反序列化引擎engine(根据trtModelStream反序列化)
|
||
assert(pEngine_ != nullptr);
|
||
//3.创建上下文环境
|
||
pContext_ = pEngine_->createExecutionContext(); //创建上下文环境,主要用于inference函数中启动cuda核
|
||
assert(pContext_ != nullptr);
|
||
delete[] trtModelStream; //析构trtModelStream
|
||
std::cout<<"Engine get NB Bindings is: "<<pEngine_->getNbBindings()<<std::endl;
|
||
assert(pEngine_->getNbBindings() == 2);
|
||
|
||
//获取绑定的输入输入
|
||
uiInputIndex_ = pEngine_->getBindingIndex((pRetinanetClassifyModelInfo_->strInputBlobName).c_str());
|
||
uiOutputIndex_ = pEngine_->getBindingIndex((pRetinanetClassifyModelInfo_->strOutputBlobName).c_str());
|
||
std::cout<<"inputIndex: "<<uiInputIndex_<<"\toutputIndex: "<<uiOutputIndex_<<std::endl;
|
||
assert(uiInputIndex_ == 0);
|
||
assert(uiOutputIndex_ == 1);
|
||
|
||
return 0;
|
||
}
|
||
|
||
int RetinanetClassifyInference::RetinanetClassifyInferenceDeInit()
|
||
{
|
||
//资源释放
|
||
CUDA_CHECK(cudaStreamDestroy(*pImagePreprocessStream_)); //释放图像预处理CUDA流
|
||
if(pImagePreprocessStream_){
|
||
delete pImagePreprocessStream_;
|
||
pImagePreprocessStream_ = nullptr;
|
||
}
|
||
|
||
CUDA_CHECK(cudaStreamDestroy(*pInferenceModelStream_)); //释放模型推理CUDA流
|
||
if(pInferenceModelStream_){ //释放模型推理CUDA流
|
||
delete pInferenceModelStream_;
|
||
pInferenceModelStream_ = nullptr;
|
||
}
|
||
|
||
CUDA_CHECK(cudaFree(pu8ImgDevice_)); //释放设备端内存
|
||
CUDA_CHECK(cudaFreeHost(pu8ImgHost_)); //释放HOST端内存
|
||
|
||
CUDA_CHECK(cudaFree(pfBuffers_[0])); //释放输入数据设备端内存
|
||
CUDA_CHECK(cudaFree(pfBuffers_[1])); //释放输出数据设备端内存
|
||
|
||
//析构engine引擎资源
|
||
pContext_->destroy(); //析构绘话
|
||
pEngine_->destroy(); //析构TensorRT引擎
|
||
pRuntime_->destroy(); //析构运行时环境
|
||
|
||
if(pGLogger_){ //释放Logger
|
||
delete pGLogger_;
|
||
pGLogger_ = nullptr;
|
||
}
|
||
|
||
if(pfInputData_){
|
||
delete[] pfInputData_;
|
||
pfInputData_ = nullptr;
|
||
}
|
||
|
||
if(pfOutputData_){
|
||
delete[] pfOutputData_;
|
||
pfOutputData_ = nullptr;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
bool RetinanetClassifyInference::RetinanetClassifyInferenceModel(cv::Mat& frame)
|
||
{
|
||
size_t size_image_src = frame.cols * frame.rows * pRetinanetClassifyModelInfo_->uiChannel;
|
||
unsigned int img_width = frame.cols, img_height = frame.rows;
|
||
size_t size_image_dst = pRetinanetClassifyModelInfo_->uiModelWidth * pRetinanetClassifyModelInfo_->uiModelHeight * pRetinanetClassifyModelInfo_->uiChannel;
|
||
auto preprocess_start = std::chrono::system_clock::now(); //计时开始
|
||
|
||
// printf("frame cols: %d\t frame rows: %d\n", frame.cols, frame.rows);
|
||
// printf("model witdh: %d\t model height: %d\t model channle: %d\n", pRetinanetClassifyModelInfo_->uiModelWidth,
|
||
// pRetinanetClassifyModelInfo_->uiModelHeight, pRetinanetClassifyModelInfo_->uiChannel);
|
||
#ifdef ENABLE_CUDA_PREPROCESS
|
||
memcpy(pu8ImgHost_, frame.data, size_image_src); //拷贝预处理数据到HOST侧
|
||
CUDA_CHECK(cudaMemcpyAsync(pu8ImgDevice_, pu8ImgHost_, size_image_src, cudaMemcpyHostToDevice, *pImagePreprocessStream_)); //拷贝预处理数据到Device侧
|
||
retinanet_classify_preprocess_kernel_img(pu8ImgDevice_, frame.cols, frame.rows, (float*)pfBuffers_[0], pRetinanetClassifyModelInfo_->uiModelWidth, pRetinanetClassifyModelInfo_->uiModelHeight, *pImagePreprocessStream_);
|
||
cudaStreamSynchronize(*pImagePreprocessStream_);
|
||
#else
|
||
cv::Mat pr_img = preprocess_img(frame, pRetinanetClassifyModelInfo_->uiModelWidth, pRetinanetClassifyModelInfo_->uiModelHeight); // letterbox BGR to RGB
|
||
int n = 0;
|
||
for (int row = 0; row < pRetinanetClassifyModelInfo_->uiModelHeight; ++row) {
|
||
uchar* uc_pixel = pr_img.data + row * pr_img.step;
|
||
for (int col = 0; col < pRetinanetClassifyModelInfo_->uiModelWidth; ++col) {
|
||
pfInputData_[n] = (float)uc_pixel[2] - 104;
|
||
pfInputData_[n + pRetinanetClassifyModelInfo_->uiModelHeight * pRetinanetClassifyModelInfo_->uiModelWidth] = (float)uc_pixel[1] - 117;
|
||
pfInputData_[n + 2 * pRetinanetClassifyModelInfo_->uiModelHeight * pRetinanetClassifyModelInfo_->uiModelWidth] = (float)uc_pixel[0] - 123;
|
||
uc_pixel += pRetinanetClassifyModelInfo_->uiChannel;
|
||
++n;
|
||
}
|
||
}
|
||
#endif
|
||
auto preprocess_end = std::chrono::system_clock::now();
|
||
// std::cout << "retinanet classify preprocess time: " << std::chrono::duration_cast<std::chrono::milliseconds>(preprocess_end - preprocess_start).count() << "ms" << std::endl;
|
||
//2.推理
|
||
auto start = std::chrono::system_clock::now(); //计时开始
|
||
#ifdef ENABLE_CUDA_PREPROCESS
|
||
doInferenceV2(*pContext_, *pInferenceModelStream_, (void**)pfBuffers_,
|
||
uiOutputIndex_, pfOutputData_, pRetinanetClassifyModelInfo_->uiOutputSize,
|
||
pRetinanetClassifyModelInfo_->uiBatchSize);
|
||
#else
|
||
float a[2]={0};
|
||
doInference(*pContext_, *pInferenceModelStream_, (void**)pfBuffers_,
|
||
uiInputIndex_, pfInputData_, pRetinanetClassifyModelInfo_->uiInputSize,
|
||
uiOutputIndex_, pfOutputData_, pRetinanetClassifyModelInfo_->uiOutputSize,
|
||
pRetinanetClassifyModelInfo_->uiBatchSize);
|
||
#endif
|
||
auto end = std::chrono::system_clock::now();
|
||
// std::cout << "retinanet classify inference time: " << std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() << "ms" << std::endl;
|
||
|
||
//3.后处理
|
||
std::cout.setf(std::ios_base::fixed, std::ios_base::floatfield);
|
||
// std::cout<<"after inference retinanet classify output[0] is: "<<pfOutputData_[0]<<" output[1] is: "<<pfOutputData_[2]<<std::endl;
|
||
if(pfOutputData_[0] < pfOutputData_[1]){
|
||
return true;
|
||
}else{
|
||
return false;
|
||
}
|
||
}
|