mmr/tkDNN
Archived
1
0
Fork 0
Code Issues 46 Pull Requests 12 Releases 4 Activity

Adapt detection classes to use batches, adapt demos, update README

Browse Source 
Signed-off-by: Micaela Verucchi <micaelaverucchi@gmail.com>
This commit is contained in:
Micaela Verucchi
2020-05-14 16:41:51 +02:00
parent 2e3cb52cff
commit 40456592fc
10 changed files with 149 additions and 103 deletions
Download Patch File Download Diff File Expand all files Collapse all files
README.md
+6 -1
View File
@@ -123,13 +123,16 @@ rm yolo3_fp32.rt # be sure to delete(or move) old tensorRT files
``` ```
In general the demo program takes 4 parameters: In general the demo program takes 4 parameters:
``` ```
./demo <network-rt-file> <path-to-video> <kind-of-network> <number-of-classes> ./demo <network-rt-file> <path-to-video> <kind-of-network> <number-of-classes> <n-batches> <show-flag>
``` ```
where where
* ```<network-rt-file>``` is the rt file generated by a test * ```<network-rt-file>``` is the rt file generated by a test
* ```<<path-to-video>``` is the path to a video file or a camera input * ```<<path-to-video>``` is the path to a video file or a camera input
* ```<kind-of-network>``` is the type of network. Thee types are currently supported: ```y``` (YOLO family), ```c``` (CenterNet family) and ```m``` (MobileNet-SSD family) * ```<kind-of-network>``` is the type of network. Thee types are currently supported: ```y``` (YOLO family), ```c``` (CenterNet family) and ```m``` (MobileNet-SSD family)
* ```<number-of-classes>```is the number of classes the network is trained on * ```<number-of-classes>```is the number of classes the network is trained on
* ```<n-batches>``` number of batches to use in inference (N.B. you should first export TKDNN_BATCHSIZE to the required n_batches and create again the rt file for the network).
* ```<show-flag>``` if set to 0 the demo will not show the visualization but save the video into result.mp4 (if n-batches ==1)
N.b. By default it is used FP32 inference N.b. By default it is used FP32 inference
![demo](https://user-images.githubusercontent.com/11562617/72547657-540e7800-388d-11ea-83c6-49dfea2a0607.gif) ![demo](https://user-images.githubusercontent.com/11562617/72547657-540e7800-388d-11ea-83c6-49dfea2a0607.gif)
@@ -218,6 +221,8 @@ cd build
./map_demo dla34_cnet_FP32.rt c ../demo/COCO_val2017/all_labels.txt ../demo/config.yaml ./map_demo dla34_cnet_FP32.rt c ../demo/COCO_val2017/all_labels.txt ../demo/config.yaml
``` ```
This demo also creates a json file named ```net_name_COCO_res.json``` containing all the detections computed. The detections are in COCO format, the correct format to subit the results to [CodaLab COCO detection challenge](https://competitions.codalab.org/competitions/20794#participate).
## Existing tests and supported networks ## Existing tests and supported networks
| Test Name | Network | Dataset | N Classes | Input size | Weights | | Test Name | Network | Dataset | N Classes | Input size | Weights |
demo/demo/demo.cpp
+37 -21
View File
@@ -34,9 +34,15 @@ int main(int argc, char *argv[]) {
int n_classes = 80; int n_classes = 80;
if(argc > 4) if(argc > 4)
n_classes = atoi(argv[4]); n_classes = atoi(argv[4]);
bool show = true; int n_batch = 1;
if(argc > 5) if(argc > 5)
show = atoi(argv[5]); n_batch = atoi(argv[5]);
bool show = true;
if(argc > 6)
show = atoi(argv[6]);
if(n_batch < 1 || n_batch > 64)
FatalError("Batch dim not supported");
if(!show) if(!show)
SAVE_RESULT = true; SAVE_RESULT = true;
@@ -63,7 +69,7 @@ int main(int argc, char *argv[]) {
FatalError("Network type not allowed (3rd parameter)\n"); FatalError("Network type not allowed (3rd parameter)\n");
} }
detNN->init(net, n_classes); detNN->init(net, n_classes, n_batch);
gRun = true; gRun = true;
@@ -81,30 +87,40 @@ int main(int argc, char *argv[]) {
} }
cv::Mat frame; cv::Mat frame;
cv::Mat dnn_input;
if(show) if(show)
cv::namedWindow("detection", cv::WINDOW_NORMAL); cv::namedWindow("detection", cv::WINDOW_NORMAL);
std::vector<tk::dnn::box> detected_bbox; std::vector<cv::Mat> batch_frame;
std::vector<cv::Mat> batch_dnn_input;
while(gRun) { while(gRun) {
cap >> frame; batch_dnn_input.clear();
if(!frame.data) { batch_frame.clear();
break;
}
// this will be resized to the net format
dnn_input = frame.clone();
for(int bi=0; bi< n_batch; ++bi){
cap >> frame;
if(!frame.data)
break;
batch_frame.push_back(frame);
// this will be resized to the net format
batch_dnn_input.push_back(frame.clone());
}
if(!frame.data)
break;
//inference //inference
detNN->update(dnn_input); detNN->update(batch_dnn_input);
frame = detNN->draw(frame); detNN->draw(batch_frame);
if(show){ if(show){
cv::imshow("detection", frame); for(int bi=0; bi< n_batch; ++bi){
cv::waitKey(1); cv::imshow("detection", batch_frame[bi]);
cv::waitKey(1);
}
} }
if(SAVE_RESULT) if(n_batch == 1 && SAVE_RESULT)
resultVideo << frame; resultVideo << frame;
} }
@@ -112,10 +128,10 @@ int main(int argc, char *argv[]) {
double mean = 0; double mean = 0;
std::cout<<COL_GREENB<<"\n\nTime stats:\n"; std::cout<<COL_GREENB<<"\n\nTime stats:\n";
std::cout<<"Min: "<<*std::min_element(detNN->stats.begin(), detNN->stats.end())<<" ms\n"; std::cout<<"Min: "<<*std::min_element(detNN->stats.begin(), detNN->stats.end())/n_batch<<" ms\n";
std::cout<<"Max: "<<*std::max_element(detNN->stats.begin(), detNN->stats.end())<<" ms\n"; std::cout<<"Max: "<<*std::max_element(detNN->stats.begin(), detNN->stats.end())/n_batch<<" ms\n";
for(int i=0; i<detNN->stats.size(); i++) mean += detNN->stats[i]; mean /= detNN->stats.size(); for(int i=0; i<detNN->stats.size(); i++) mean += detNN->stats[i]; mean /= detNN->stats.size();
std::cout<<"Avg: "<<mean<<" ms\n"<<COL_END; std::cout<<"Avg: "<<mean/n_batch<<" ms\n"<<COL_END;
return 0; return 0;
demo/demo/map.cpp
+9 -8
View File
@@ -132,19 +132,20 @@ int main(int argc, char *argv[])
FatalError("Wrong image file path."); FatalError("Wrong image file path.");
cv::Mat frame = cv::imread(f.iFilename.c_str(), cv::IMREAD_COLOR); cv::Mat frame = cv::imread(f.iFilename.c_str(), cv::IMREAD_COLOR);
std::vector<cv::Mat> batch_frames;
batch_frames.push_back(frame);
int height = frame.rows; int height = frame.rows;
int width = frame.cols; int width = frame.cols;
cv::Mat dnn_input;
if(!frame.data) if(!frame.data)
break; break;
dnn_input = frame.clone(); std::vector<cv::Mat> batch_dnn_input;
batch_dnn_input.push_back(frame.clone());
//inference //inference
detected_bbox.clear(); detected_bbox.clear();
detNN->update(dnn_input, write_res_on_file, &times, write_coco_json); detNN->update(batch_dnn_input, write_res_on_file, &times, write_coco_json);
frame = detNN->draw(frame); detNN->draw(batch_frames);
detected_bbox = detNN->detected; detected_bbox = detNN->detected;
if(write_coco_json) if(write_coco_json)
@@ -171,7 +172,7 @@ int main(int argc, char *argv[])
myfile << d.cl << " "<< d.prob << " "<< d.x << " "<< d.y << " "<< d.w << " "<< d.h <<"\n"; myfile << d.cl << " "<< d.prob << " "<< d.x << " "<< d.y << " "<< d.w << " "<< d.h <<"\n";
if(show)// draw rectangle for detection if(show)// draw rectangle for detection
cv::rectangle(frame, cv::Point(d.x, d.y), cv::Point(d.x + d.w, d.y + d.h), cv::Scalar(0, 0, 255), 2); cv::rectangle(batch_frames[0], cv::Point(d.x, d.y), cv::Point(d.x + d.w, d.y + d.h), cv::Scalar(0, 0, 255), 2);
} }
if(write_dets) if(write_dets)
@@ -190,14 +191,14 @@ int main(int argc, char *argv[])
f.gt.push_back(b); f.gt.push_back(b);
if(show)// draw rectangle for groundtruth if(show)// draw rectangle for groundtruth
cv::rectangle(frame, cv::Point((b.x-b.w/2)*width, (b.y-b.h/2)*height), cv::Point((b.x+b.w/2)*width,(b.y+b.h/2)*height), cv::Scalar(0, 255, 0), 2); cv::rectangle(batch_frames[0], cv::Point((b.x-b.w/2)*width, (b.y-b.h/2)*height), cv::Point((b.x+b.w/2)*width,(b.y+b.h/2)*height), cv::Scalar(0, 255, 0), 2);
} }
} }
images.push_back(f); images.push_back(f);
if(show){ if(show){
cv::imshow("detection", frame); cv::imshow("detection", batch_frames[0]);
cv::waitKey(0); cv::waitKey(0);
} }
include/tkDNN/CenternetDetection.h
+3 -3
View File
@@ -73,9 +73,9 @@ public:
CenternetDetection() {}; CenternetDetection() {};
~CenternetDetection() {}; ~CenternetDetection() {};
bool init(const std::string& tensor_path, const int n_classes=80); bool init(const std::string& tensor_path, const int n_classes=80, const int n_batches=1);
void preprocess(cv::Mat &frame); void preprocess(cv::Mat &frame, const int bi=0);
void postprocess(const bool mAP=false); void postprocess(const int bi=0,const bool mAP=false);
}; };
include/tkDNN/DetectionNN.h
+45 -30
View File
@@ -34,6 +34,8 @@ class DetectionNN {
cv::Scalar colors[256]; cv::Scalar colors[256];
int nBatches = 1;
#ifdef OPENCV_CUDACONTRIB #ifdef OPENCV_CUDACONTRIB
cv::cuda::GpuMat bgr[3]; cv::cuda::GpuMat bgr[3];
cv::cuda::GpuMat imagePreproc; cv::cuda::GpuMat imagePreproc;
@@ -47,21 +49,26 @@ class DetectionNN {
* This method preprocess the image, before feeding it to the NN. * This method preprocess the image, before feeding it to the NN.
* *
* @param frame original frame to adapt for inference. * @param frame original frame to adapt for inference.
* @param bi batch index
*/ */
virtual void preprocess(cv::Mat &frame) = 0; virtual void preprocess(cv::Mat &frame, const int bi=0) = 0;
/** /**
* This method postprocess the output of the NN to obtain the correct * This method postprocess the output of the NN to obtain the correct
* boundig boxes. * boundig boxes.
* *
* @param bi batch index
* @param mAP set to true only if all the probabilities for a bounding
* box are needed, as in some cases for the mAP calculation
*/ */
virtual void postprocess(const bool mAP=false) = 0; virtual void postprocess(const int bi=0,const bool mAP=false) = 0;
public: public:
int classes = 0; int classes = 0;
float confThreshold = 0.05; /*threshold on the confidence of the boxes*/ float confThreshold = 0.3; /*threshold on the confidence of the boxes*/
std::vector<tk::dnn::box> detected; /*bounding boxes in output*/ std::vector<tk::dnn::box> detected; /*bounding boxes in output*/
std::vector<std::vector<tk::dnn::box>> batchDetected; /*bounding boxes in output*/
std::vector<double> stats; /*keeps track of inference times (ms)*/ std::vector<double> stats; /*keeps track of inference times (ms)*/
std::vector<std::string> classesNames; std::vector<std::string> classesNames;
@@ -74,36 +81,41 @@ class DetectionNN {
* *
* @param tensor_path path to the rt file og the NN. * @param tensor_path path to the rt file og the NN.
* @param n_classes number of classes for the given dataset. * @param n_classes number of classes for the given dataset.
* @param n_batches number of batches to use in inference
* @return true if everything is correct, false otherwise. * @return true if everything is correct, false otherwise.
*/ */
virtual bool init(const std::string& tensor_path, const int n_classes=80) = 0; virtual bool init(const std::string& tensor_path, const int n_classes=80, const int n_batches=1) = 0;
/** /**
* This method performs the whole detection of the NN. * This method performs the whole detection of the NN.
* *
* @param frame frame to run detection on. * @param frames frames to run detection on.
* @param save_times if set to true, preprocess, inference and postprocess times * @param save_times if set to true, preprocess, inference and postprocess times
* are saved on a csv file, otherwise not. * are saved on a csv file, otherwise not.
* @param times pointer to the output stream where to write times * @param times pointer to the output stream where to write times
* @param mAP set to true only if all the probabilities for a bounding
* box are needed, as in some cases for the mAP calculation
*/ */
void update(cv::Mat &frame, bool save_times=false, std::ofstream *times=nullptr, const bool mAP=false){ void update(std::vector<cv::Mat>& frames, bool save_times=false, std::ofstream *times=nullptr, const bool mAP=false){
if(!frame.data)
FatalError("No image data feed to detection");
if(save_times && times==nullptr) if(save_times && times==nullptr)
FatalError("save_times set to true, but no valid ofstream given"); FatalError("save_times set to true, but no valid ofstream given");
originalSize = frame.size();
printCenteredTitle(" TENSORRT detection ", '=', 30); printCenteredTitle(" TENSORRT detection ", '=', 30);
{ {
TIMER_START TIMER_START
preprocess(frame); for(int bi=0; bi<nBatches;++bi){
if(!frames[bi].data)
FatalError("No image data feed to detection");
originalSize = frames[bi].size();
preprocess(frames[bi], bi);
}
TIMER_STOP TIMER_STOP
if(save_times) *times<<t_ns<<";"; if(save_times) *times<<t_ns<<";";
} }
//do inference //do inference
tk::dnn::dataDim_t dim = netRT->input_dim; tk::dnn::dataDim_t dim = netRT->input_dim;
dim.n = nBatches;
{ {
dim.print(); dim.print();
TIMER_START TIMER_START
@@ -114,9 +126,11 @@ class DetectionNN {
if(save_times) *times<<t_ns<<";"; if(save_times) *times<<t_ns<<";";
} }
batchDetected.clear();
{ {
TIMER_START TIMER_START
postprocess(mAP); for(int bi=0; bi<nBatches;++bi)
postprocess(bi, mAP);
TIMER_STOP TIMER_STOP
if(save_times) *times<<t_ns<<"\n"; if(save_times) *times<<t_ns<<"\n";
} }
@@ -125,10 +139,9 @@ class DetectionNN {
/** /**
* Method to draw boundixg boxes and labels on a frame. * Method to draw boundixg boxes and labels on a frame.
* *
* @param frame orginal frame to draw bounding box on. * @param frames orginal frame to draw bounding box on.
* @return frame with boundig boxes.
*/ */
cv::Mat draw(cv::Mat &frame) { void draw(std::vector<cv::Mat>& frames) {
tk::dnn::box b; tk::dnn::box b;
int x0, w, x1, y0, h, y1; int x0, w, x1, y0, h, y1;
int objClass; int objClass;
@@ -137,24 +150,26 @@ class DetectionNN {
int baseline = 0; int baseline = 0;
float font_scale = 0.5; float font_scale = 0.5;
int thickness = 2; int thickness = 2;
// draw dets
for(int i=0; i<detected.size(); i++) {
b = detected[i];
x0 = b.x;
x1 = b.x + b.w;
y0 = b.y;
y1 = b.y + b.h;
det_class = classesNames[b.cl];
// draw rectangle for(int bi=0; bi<frames.size(); ++bi){
cv::rectangle(frame, cv::Point(x0, y0), cv::Point(x1, y1), colors[b.cl], 2); // draw dets
for(int i=0; i<batchDetected[bi].size(); i++) {
b = batchDetected[bi][i];
x0 = b.x;
x1 = b.x + b.w;
y0 = b.y;
y1 = b.y + b.h;
det_class = classesNames[b.cl];
// draw label // draw rectangle
cv::Size text_size = getTextSize(det_class, cv::FONT_HERSHEY_SIMPLEX, font_scale, thickness, &baseline); cv::rectangle(frames[bi], cv::Point(x0, y0), cv::Point(x1, y1), colors[b.cl], 2);
cv::rectangle(frame, cv::Point(x0, y0), cv::Point((x0 + text_size.width - 2), (y0 - text_size.height - 2)), colors[b.cl], -1);
cv::putText(frame, det_class, cv::Point(x0, (y0 - (baseline / 2))), cv::FONT_HERSHEY_SIMPLEX, font_scale, cv::Scalar(255, 255, 255), thickness); // draw label
cv::Size text_size = getTextSize(det_class, cv::FONT_HERSHEY_SIMPLEX, font_scale, thickness, &baseline);
cv::rectangle(frames[bi], cv::Point(x0, y0), cv::Point((x0 + text_size.width - 2), (y0 - text_size.height - 2)), colors[b.cl], -1);
cv::putText(frames[bi], det_class, cv::Point(x0, (y0 - (baseline / 2))), cv::FONT_HERSHEY_SIMPLEX, font_scale, cv::Scalar(255, 255, 255), thickness);
}
} }
return frame;
} }
}; };
include/tkDNN/MobilenetDetection.h
+3 -3
View File
@@ -65,9 +65,9 @@ public:
MobilenetDetection() {}; MobilenetDetection() {};
~MobilenetDetection() {}; ~MobilenetDetection() {};
bool init(const std::string& tensor_path, const int n_classes); bool init(const std::string& tensor_path, const int n_classes, const int n_batches=1);
void preprocess(cv::Mat &frame); void preprocess(cv::Mat &frame, const int bi=0);
void postprocess(const bool mAP=false); void postprocess(const int bi=0,const bool mAP=false);
}; };
include/tkDNN/Yolo3Detection.h
+3 -3
View File
@@ -24,9 +24,9 @@ public:
Yolo3Detection() {}; Yolo3Detection() {};
~Yolo3Detection() {}; ~Yolo3Detection() {};
bool init(const std::string& tensor_path, const int n_classes=80); bool init(const std::string& tensor_path, const int n_classes=80, const int n_batches=1);
void preprocess(cv::Mat &frame); void preprocess(cv::Mat &frame, const int bi=0);
void postprocess(const bool mAP=false); void postprocess(const int bi=0,const bool mAP=false);
}; };
src/CenternetDetection.cpp
+14 -12
View File
@@ -3,10 +3,11 @@
namespace tk { namespace dnn { namespace tk { namespace dnn {
bool CenternetDetection::init(const std::string& tensor_path, const int n_classes){ bool CenternetDetection::init(const std::string& tensor_path, const int n_classes, const int n_batches){
std::cout<<(tensor_path).c_str()<<"\n"; std::cout<<(tensor_path).c_str()<<"\n";
netRT = new tk::dnn::NetworkRT(NULL, (tensor_path).c_str() ); netRT = new tk::dnn::NetworkRT(NULL, (tensor_path).c_str() );
classes = n_classes; classes = n_classes;
nBatches = n_batches;
dim = netRT->input_dim; dim = netRT->input_dim;
@@ -41,7 +42,7 @@ bool CenternetDetection::init(const std::string& tensor_path, const int n_classe
trans = cv::Mat(cv::Size(3,2), CV_32F); trans = cv::Mat(cv::Size(3,2), CV_32F);
trans2 = cv::Mat(cv::Size(3,2), CV_32F); trans2 = cv::Mat(cv::Size(3,2), CV_32F);
checkCuda(cudaMalloc(&input_d, sizeof(dnnType)*netRT->input_dim.tot())); checkCuda(cudaMalloc(&input_d, sizeof(dnnType)*netRT->input_dim.tot() * nBatches));
dim_hm = tk::dnn::dataDim_t(1, 80, 128, 128, 1); dim_hm = tk::dnn::dataDim_t(1, 80, 128, 128, 1);
dim_wh = tk::dnn::dataDim_t(1, 2, 128, 128, 1); dim_wh = tk::dnn::dataDim_t(1, 2, 128, 128, 1);
@@ -98,7 +99,7 @@ bool CenternetDetection::init(const std::string& tensor_path, const int n_classe
checkCuda(cudaMemcpy(mean_d, mean, 3*sizeof(float), cudaMemcpyHostToDevice)); checkCuda(cudaMemcpy(mean_d, mean, 3*sizeof(float), cudaMemcpyHostToDevice));
checkCuda(cudaMemcpy(stddev_d, stddev, 3*sizeof(float), cudaMemcpyHostToDevice)); checkCuda(cudaMemcpy(stddev_d, stddev, 3*sizeof(float), cudaMemcpyHostToDevice));
#else #else
checkCuda(cudaMallocHost(&input, sizeof(dnnType)*netRT->input_dim.tot())); checkCuda(cudaMallocHost(&input, sizeof(dnnType)*netRT->input_dim.tot()* nBatches));
mean << 0.408, 0.447, 0.47; mean << 0.408, 0.447, 0.47;
stddev << 0.289, 0.274, 0.278; stddev << 0.289, 0.274, 0.278;
#endif #endif
@@ -120,7 +121,7 @@ bool CenternetDetection::init(const std::string& tensor_path, const int n_classe
} }
void CenternetDetection::preprocess(cv::Mat &frame){ void CenternetDetection::preprocess(cv::Mat &frame, const int bi){
// -----------------------------------pre-process ------------------------------------------ // -----------------------------------pre-process ------------------------------------------
// auto start_t = std::chrono::steady_clock::now(); // auto start_t = std::chrono::steady_clock::now();
@@ -212,7 +213,7 @@ void CenternetDetection::preprocess(cv::Mat &frame){
// std::cout << " TIME normalize: " << std::chrono::duration_cast<std::chrono:: microseconds>(end_t - step_t).count() << " us" << std::endl; // std::cout << " TIME normalize: " << std::chrono::duration_cast<std::chrono:: microseconds>(end_t - step_t).count() << " us" << std::endl;
// step_t = end_t; // step_t = end_t;
checkCuda(cudaMemcpy(input_d, d_ptrs, dim2.tot()*sizeof(dnnType), cudaMemcpyDeviceToDevice)); checkCuda(cudaMemcpy(input_d+ netRT->input_dim.tot()*bi, d_ptrs, dim2.tot()*sizeof(dnnType), cudaMemcpyDeviceToDevice));
// end_t = std::chrono::steady_clock::now(); // end_t = std::chrono::steady_clock::now();
// std::cout << " TIME Memcpy to input_d: " << std::chrono::duration_cast<std::chrono:: microseconds>(end_t - step_t).count() << " us" << std::endl; // std::cout << " TIME Memcpy to input_d: " << std::chrono::duration_cast<std::chrono:: microseconds>(end_t - step_t).count() << " us" << std::endl;
@@ -254,18 +255,18 @@ void CenternetDetection::preprocess(cv::Mat &frame){
int idx = i*imageF.rows*imageF.cols; int idx = i*imageF.rows*imageF.cols;
int ch = dim2.c-3 +i; int ch = dim2.c-3 +i;
// std::cout<<"i: "<<i<<", idx: "<<idx<<", ch: "<<ch<<std::endl; // std::cout<<"i: "<<i<<", idx: "<<idx<<", ch: "<<ch<<std::endl;
memcpy((void*)&input[idx], (void*)bgr[ch].data, imageF.rows*imageF.cols*sizeof(dnnType)); memcpy((void*)&input[idx+ netRT->input_dim.tot()*bi], (void*)bgr[ch].data, imageF.rows*imageF.cols*sizeof(dnnType));
} }
checkCuda(cudaMemcpyAsync(input_d, input, dim2.tot()*sizeof(dnnType), cudaMemcpyHostToDevice)); checkCuda(cudaMemcpyAsync(input_d+ netRT->input_dim.tot()*bi, input+ netRT->input_dim.tot()*bi, dim2.tot()*sizeof(dnnType), cudaMemcpyHostToDevice));
#endif #endif
} }
void CenternetDetection::postprocess(const bool mAP){ void CenternetDetection::postprocess(const int bi, const bool mAP){
dnnType *rt_out[4]; dnnType *rt_out[4];
rt_out[0] = (dnnType *)netRT->buffersRT[1]; rt_out[0] = (dnnType *)netRT->buffersRT[1]+ netRT->buffersDIM[0].tot()*bi;
rt_out[1] = (dnnType *)netRT->buffersRT[2]; rt_out[1] = (dnnType *)netRT->buffersRT[2]+ netRT->buffersDIM[1].tot()*bi;
rt_out[2] = (dnnType *)netRT->buffersRT[3]; rt_out[2] = (dnnType *)netRT->buffersRT[3]+ netRT->buffersDIM[2].tot()*bi;
rt_out[3] = (dnnType *)netRT->buffersRT[4]; rt_out[3] = (dnnType *)netRT->buffersRT[4]+ netRT->buffersDIM[3].tot()*bi;
// auto start_t = std::chrono::steady_clock::now(); // auto start_t = std::chrono::steady_clock::now();
// auto step_t = std::chrono::steady_clock::now(); // auto step_t = std::chrono::steady_clock::now();
@@ -389,6 +390,7 @@ void CenternetDetection::postprocess(const bool mAP){
} }
} }
batchDetected.push_back(detected);
// end_t = std::chrono::steady_clock::now(); // end_t = std::chrono::steady_clock::now();
// std::cout << " TIME detections: " << std::chrono::duration_cast<std::chrono:: microseconds>(end_t - step_t).count() << " us" << std::endl; // std::cout << " TIME detections: " << std::chrono::duration_cast<std::chrono:: microseconds>(end_t - step_t).count() << " us" << std::endl;
// step_t = end_t; // step_t = end_t;
src/MobilenetDetection.cpp
+12 -10
View File
@@ -126,11 +126,12 @@ float MobilenetDetection::iou(const tk::dnn::box &a, const tk::dnn::box &b){
return iou; return iou;
} }
bool MobilenetDetection::init(const std::string& tensor_path, const int n_classes){ bool MobilenetDetection::init(const std::string& tensor_path, const int n_classes, const int n_batches){
std::cout<<(tensor_path).c_str()<<"\n"; std::cout<<(tensor_path).c_str()<<"\n";
netRT = new tk::dnn::NetworkRT(NULL, (tensor_path).c_str()); netRT = new tk::dnn::NetworkRT(NULL, (tensor_path).c_str());
imageSize = netRT->input_dim.h; imageSize = netRT->input_dim.h;
classes = n_classes; classes = n_classes;
nBatches = n_batches;
SSDSpec specs[N_SSDSPEC]; SSDSpec specs[N_SSDSPEC];
@@ -157,9 +158,9 @@ bool MobilenetDetection::init(const std::string& tensor_path, const int n_classe
generate_ssd_priors(specs, N_SSDSPEC); generate_ssd_priors(specs, N_SSDSPEC);
#ifndef OPENCV_CUDACONTRIB #ifndef OPENCV_CUDACONTRIB
checkCuda(cudaMallocHost(&input, sizeof(dnnType) * netRT->input_dim.tot())); checkCuda(cudaMallocHost(&input, sizeof(dnnType) * netRT->input_dim.tot() * nBatches));
#endif #endif
checkCuda(cudaMalloc(&input_d, sizeof(dnnType) * netRT->input_dim.tot())); checkCuda(cudaMalloc(&input_d, sizeof(dnnType) * netRT->input_dim.tot() * nBatches));
locations_h = (float *)malloc(N_COORDS * nPriors * sizeof(float)); locations_h = (float *)malloc(N_COORDS * nPriors * sizeof(float));
confidences_h = (float *)malloc(nPriors * classes * sizeof(float)); confidences_h = (float *)malloc(nPriors * classes * sizeof(float));
@@ -208,7 +209,7 @@ bool MobilenetDetection::init(const std::string& tensor_path, const int n_classe
return 1; return 1;
} }
void MobilenetDetection::preprocess(cv::Mat &frame){ void MobilenetDetection::preprocess(cv::Mat &frame, const int bi){
#ifdef OPENCV_CUDACONTRIB #ifdef OPENCV_CUDACONTRIB
//move original image on GPU //move original image on GPU
cv::cuda::GpuMat orig_img, frame_nomean; cv::cuda::GpuMat orig_img, frame_nomean;
@@ -224,7 +225,7 @@ void MobilenetDetection::preprocess(cv::Mat &frame){
for(int i=0; i < netRT->input_dim.c; i++){ for(int i=0; i < netRT->input_dim.c; i++){
int idx = i * imagePreproc.rows * imagePreproc.cols; int idx = i * imagePreproc.rows * imagePreproc.cols;
checkCuda( cudaMemcpy((void *)&input_d[idx], (void *)bgr[i].data, imagePreproc.rows * imagePreproc.cols* sizeof(float), cudaMemcpyDeviceToDevice) ); checkCuda( cudaMemcpy((void *)&input_d[idx + netRT->input_dim.tot()*bi], (void *)bgr[i].data, imagePreproc.rows * imagePreproc.cols* sizeof(float), cudaMemcpyDeviceToDevice) );
} }
#else #else
//resize image, remove mean, divide by std //resize image, remove mean, divide by std
@@ -237,17 +238,17 @@ void MobilenetDetection::preprocess(cv::Mat &frame){
cv::split(imagePreproc, bgr); cv::split(imagePreproc, bgr);
for (int i = 0; i < netRT->input_dim.c; i++){ for (int i = 0; i < netRT->input_dim.c; i++){
int idx = i * imagePreproc.rows * imagePreproc.cols; int idx = i * imagePreproc.rows * imagePreproc.cols;
memcpy((void *)&input[idx], (void *)bgr[i].data, imagePreproc.rows * imagePreproc.cols * sizeof(dnnType)); memcpy((void *)&input[idx + netRT->input_dim.tot()*bi], (void *)bgr[i].data, imagePreproc.rows * imagePreproc.cols * sizeof(dnnType));
} }
checkCuda(cudaMemcpyAsync(input_d, input, netRT->input_dim.tot() * sizeof(dnnType), cudaMemcpyHostToDevice, netRT->stream)); checkCuda(cudaMemcpyAsync(input_d+ netRT->input_dim.tot()*bi, input + netRT->input_dim.tot()*bi, netRT->input_dim.tot() * sizeof(dnnType), cudaMemcpyHostToDevice, netRT->stream));
#endif #endif
} }
void MobilenetDetection::postprocess(const bool mAP){ void MobilenetDetection::postprocess(const int bi, const bool mAP){
//get confidences and locations_h //get confidences and locations_h
dnnType *rt_out[2]; dnnType *rt_out[2];
rt_out[0] = (dnnType *)netRT->buffersRT[3]; rt_out[0] = (dnnType *)netRT->buffersRT[3]+ netRT->buffersDIM[3].tot()*bi;
rt_out[1] = (dnnType *)netRT->buffersRT[4]; rt_out[1] = (dnnType *)netRT->buffersRT[4]+ netRT->buffersDIM[4].tot()*bi;
detected.clear(); detected.clear();
@@ -302,6 +303,7 @@ void MobilenetDetection::postprocess(const bool mAP){
boxes = remaining; boxes = remaining;
} }
} }
batchDetected.push_back(detected);
} }
src/Yolo3Detection.cpp
+17 -12
View File
@@ -3,12 +3,16 @@
namespace tk { namespace dnn { namespace tk { namespace dnn {
bool Yolo3Detection::init(const std::string& tensor_path, const int n_classes) { bool Yolo3Detection::init(const std::string& tensor_path, const int n_classes, const int n_batches) {
//convert network to tensorRT //convert network to tensorRT
std::cout<<(tensor_path).c_str()<<"\n"; std::cout<<(tensor_path).c_str()<<"\n";
netRT = new tk::dnn::NetworkRT(NULL, (tensor_path).c_str() ); netRT = new tk::dnn::NetworkRT(NULL, (tensor_path).c_str() );
nBatches = n_batches;
tk::dnn::dataDim_t idim = netRT->input_dim;
idim.n = nBatches;
if(netRT->pluginFactory->n_yolos < 2 ) { if(netRT->pluginFactory->n_yolos < 2 ) {
FatalError("this is not yolo3"); FatalError("this is not yolo3");
} }
@@ -19,7 +23,7 @@ bool Yolo3Detection::init(const std::string& tensor_path, const int n_classes) {
num = yRT->num; num = yRT->num;
nMasks = yRT->n_masks; nMasks = yRT->n_masks;
// make a yolo layer for interpret predictions // make a yolo layer to interpret predictions
yolo[i] = new tk::dnn::Yolo(nullptr, classes, nMasks, ""); // yolo without input and bias yolo[i] = new tk::dnn::Yolo(nullptr, classes, nMasks, ""); // yolo without input and bias
yolo[i]->mask_h = new dnnType[nMasks]; yolo[i]->mask_h = new dnnType[nMasks];
yolo[i]->bias_h = new dnnType[num*nMasks*2]; yolo[i]->bias_h = new dnnType[num*nMasks*2];
@@ -31,9 +35,9 @@ bool Yolo3Detection::init(const std::string& tensor_path, const int n_classes) {
dets = tk::dnn::Yolo::allocateDetections(tk::dnn::Yolo::MAX_DETECTIONS, classes); dets = tk::dnn::Yolo::allocateDetections(tk::dnn::Yolo::MAX_DETECTIONS, classes);
#ifndef OPENCV_CUDACONTRIB #ifndef OPENCV_CUDACONTRIB
checkCuda(cudaMallocHost(&input, sizeof(dnnType)*netRT->input_dim.tot())); checkCuda(cudaMallocHost(&input, sizeof(dnnType)*idim.tot()));
#endif #endif
checkCuda(cudaMalloc(&input_d, sizeof(dnnType)*netRT->input_dim.tot())); checkCuda(cudaMalloc(&input_d, sizeof(dnnType)*idim.tot()));
// class colors precompute // class colors precompute
for(int c=0; c<classes; c++) { for(int c=0; c<classes; c++) {
@@ -48,7 +52,7 @@ bool Yolo3Detection::init(const std::string& tensor_path, const int n_classes) {
return true; return true;
} }
void Yolo3Detection::preprocess(cv::Mat &frame){ void Yolo3Detection::preprocess(cv::Mat &frame, const int bi){
#ifdef OPENCV_CUDACONTRIB #ifdef OPENCV_CUDACONTRIB
cv::cuda::GpuMat orig_img, img_resized; cv::cuda::GpuMat orig_img, img_resized;
orig_img = cv::cuda::GpuMat(frame); orig_img = cv::cuda::GpuMat(frame);
@@ -64,7 +68,7 @@ void Yolo3Detection::preprocess(cv::Mat &frame){
int size = imagePreproc.rows * imagePreproc.cols; int size = imagePreproc.rows * imagePreproc.cols;
int ch = netRT->input_dim.c-1 -i; int ch = netRT->input_dim.c-1 -i;
bgr[ch].download(bgr_h); //TODO: don't copy back on CPU bgr[ch].download(bgr_h); //TODO: don't copy back on CPU
checkCuda( cudaMemcpy(input_d + i*size, (float*)bgr_h.data, size*sizeof(dnnType), cudaMemcpyHostToDevice)); checkCuda( cudaMemcpy(input_d + i*size + netRT->input_dim.tot()*bi, (float*)bgr_h.data, size*sizeof(dnnType), cudaMemcpyHostToDevice));
} }
#else #else
cv::resize(frame, frame, cv::Size(netRT->input_dim.w, netRT->input_dim.h)); cv::resize(frame, frame, cv::Size(netRT->input_dim.w, netRT->input_dim.h));
@@ -77,18 +81,18 @@ void Yolo3Detection::preprocess(cv::Mat &frame){
for(int i=0; i<netRT->input_dim.c; i++) { for(int i=0; i<netRT->input_dim.c; i++) {
int idx = i*imagePreproc.rows*imagePreproc.cols; int idx = i*imagePreproc.rows*imagePreproc.cols;
int ch = netRT->input_dim.c-1 -i; int ch = netRT->input_dim.c-1 -i;
memcpy((void*)&input[idx], (void*)bgr[ch].data, imagePreproc.rows*imagePreproc.cols*sizeof(dnnType)); memcpy((void*)&input[idx + netRT->input_dim.tot()*bi], (void*)bgr[ch].data, imagePreproc.rows*imagePreproc.cols*sizeof(dnnType));
} }
checkCuda(cudaMemcpyAsync(input_d, input, netRT->input_dim.tot()*sizeof(dnnType), cudaMemcpyHostToDevice, netRT->stream)); checkCuda(cudaMemcpyAsync(input_d + netRT->input_dim.tot()*bi, input + netRT->input_dim.tot()*bi, netRT->input_dim.tot()*sizeof(dnnType), cudaMemcpyHostToDevice, netRT->stream));
#endif #endif
} }
void Yolo3Detection::postprocess(const bool mAP){ void Yolo3Detection::postprocess(const int bi, const bool mAP){
//get yolo outputs //get yolo outputs
dnnType *rt_out[netRT->pluginFactory->n_yolos]; dnnType *rt_out[netRT->pluginFactory->n_yolos];
for(int i=0; i<netRT->pluginFactory->n_yolos; i++) { for(int i=0; i<netRT->pluginFactory->n_yolos; i++)
rt_out[i] = (dnnType*)netRT->buffersRT[i+1]; rt_out[i] = (dnnType*)netRT->buffersRT[i+1] + netRT->buffersDIM[i+1].tot()*bi;
}
float x_ratio = float(originalSize.width) / float(netRT->input_dim.w); float x_ratio = float(originalSize.width) / float(netRT->input_dim.w);
float y_ratio = float(originalSize.height) / float(netRT->input_dim.h); float y_ratio = float(originalSize.height) / float(netRT->input_dim.h);
@@ -138,6 +142,7 @@ void Yolo3Detection::postprocess(const bool mAP){
detected.push_back(res); detected.push_back(res);
} }
} }
batchDetected.push_back(detected);
} }