potok/opencv
1
0
Fork 0
mirror of https://github.com/opencv/opencv.git synced 2026-07-31 08:13:04 +04:00
Code Packages Releases Wiki Activity

Merge pull request #29515 from Prasadayus:yolov3_replace

Browse Source 
Replace Qualcomm yolov3.onnx with darknet-converted yolov3 for better results
This commit is contained in:
Alexander Smorkalov
2026-07-14 12:12:26 +03:00
committed by GitHub
parent 4c936e6c18 56ae1e603b
commit a88eac3223
6 changed files with 84 additions and 168 deletions
Download Patch File Download Diff File Expand all files Collapse all files
modules/dnn/perf/perf_net.cpp
+1 -1
View File
@@ -218,7 +218,7 @@ PERF_TEST_P_(DNNTestNetwork, YOLOv3)
#endif
Mat sample = imread(findDataFile("dnn/dog416.png"));
cv::resize(sample, sample, Size(640, 640));
cv::resize(sample, sample, Size(416, 416));
Mat inp = blobFromImage(sample, 1.0 / 255.0, Size(), Scalar(), true);
processNet("dnn/yolov3.onnx", "", inp);
}
modules/dnn/test/test_darknet_importer.cpp
+16 -73
View File
@@ -117,46 +117,12 @@ public:
std::vector<Mat> outs;
net.forward(outs, net.getUnconnectedOutLayersNames());
// Detect output format: pytorch-YOLOv4 exports "boxes" [batch, N, 1, 4] + "confs" [batch, N, classes]
bool isBoxConfsFormat = (outs.size() == 2 && outs[0].dims == 4 && outs[0].size[outs[0].dims - 1] == 4);
// Detect 3-output format: boxes [batch, N, 4] + scores [batch, N] + class_idx [batch, N]
bool isBoxScoresIdxFormat = (outs.size() == 3 && outs[0].dims == 3 && outs[0].size[2] == 4);
for (int b = 0; b < batch_size; ++b)
{
std::vector<int> classIds;
std::vector<float> confidences;
std::vector<Rect2d> boxes;
if (isBoxScoresIdxFormat)
{
// yolov3-style format: boxes [batch, N, 4] + scores [batch, N] + class_idx [batch, N]
// boxes are [x1, y1, x2, y2] in pixel coords (relative to model input size)
int N = outs[0].size[1];
float* boxesPtr = outs[0].ptr<float>(b);
float* scoresPtr = outs[1].ptr<float>(b);
float* classIdxPtr = outs[2].ptr<float>(b);
float modelW = (float)inp.size[3];
float modelH = (float)inp.size[2];
for (int j = 0; j < N; ++j)
{
float score = scoresPtr[j];
if (score > confThreshold)
{
float x1 = boxesPtr[j * 4 + 0] / modelW;
float y1 = boxesPtr[j * 4 + 1] / modelH;
float x2 = boxesPtr[j * 4 + 2] / modelW;
float y2 = boxesPtr[j * 4 + 3] / modelH;
boxes.push_back(Rect2d(x1, y1, x2 - x1, y2 - y1));
confidences.push_back(score);
classIds.push_back((int)classIdxPtr[j]);
}
}
}
else if (isBoxConfsFormat)
{
// boxes [batch, N, 1, 4] (x1,y1,x2,y2), confs [batch, N, num_classes]
Mat boxesMat = outs[0];
Mat confsMat = outs[1];
if (batch_size > 1)
@@ -195,40 +161,6 @@ public:
}
}
}
else
{
for (int i = 0; i < (int)outs.size(); ++i)
{
Mat out;
if (batch_size > 1){
Range ranges[3] = {Range(b, b+1), Range::all(), Range::all()};
out = outs[i](ranges).reshape(1, outs[i].size[1]);
}else{
out = outs[i];
}
for (int j = 0; j < out.rows; ++j)
{
float objConf = out.at<float>(j, 4);
Mat scores = out.row(j).colRange(5, out.cols);
double maxClsScore;
Point maxLoc;
minMaxLoc(scores, 0, &maxClsScore, 0, &maxLoc);
double confidence = objConf * maxClsScore;
if (confidence > confThreshold) {
float* detection = out.ptr<float>(j);
double centerX = detection[0];
double centerY = detection[1];
double width = detection[2];
double height = detection[3];
boxes.push_back(Rect2d(centerX - 0.5 * width, centerY - 0.5 * height,
width, height));
confidences.push_back(confidence);
classIds.push_back(maxLoc.x);
}
}
}
}
// here we need NMS of boxes
std::vector<int> indices;
@@ -384,11 +316,17 @@ TEST_P(Test_YOLO_nets, YOLOv3)
// batchId, classId, confidence, left, top, right, bottom
const int N0 = 3;
const int N1 = 0;
const int N1 = 5;
static const float ref_[/* (N0 + N1) * 7 */] = {
0, 7, 0.606292f, 0.612037f, 0.149921f, 0.910763f, 0.300503f,
0, 16, 0.55195f, 0.17069f, 0.356024f, 0.471459f, 0.877178f,
0, 1, 0.433444f, 0.199235f, 0.301175f, 0.753253f, 0.744156f,
0, 16, 0.998835f, 0.160018f, 0.389962f, 0.417889f, 0.943715f,
0, 1, 0.987915f, 0.150904f, 0.221934f, 0.742265f, 0.746256f,
0, 7, 0.952998f, 0.614625f, 0.150259f, 0.901366f, 0.289251f,
1, 2, 0.997410f, 0.647584f, 0.459938f, 0.821038f, 0.663948f,
1, 2, 0.989632f, 0.450719f, 0.463353f, 0.496306f, 0.522258f,
1, 0, 0.980047f, 0.195857f, 0.378452f, 0.258626f, 0.629259f,
1, 9, 0.785156f, 0.665503f, 0.373544f, 0.688893f, 0.439243f,
1, 9, 0.733130f, 0.376029f, 0.315696f, 0.401777f, 0.395165f,
};
Mat ref(N0 + N1, 7, CV_32FC1, (void*)ref_);
@@ -407,7 +345,12 @@ TEST_P(Test_YOLO_nets, YOLOv3)
{
SCOPED_TRACE("batch size 1");
testYOLOModel(model_file, ref.rowRange(0, N0), scoreDiff, iouDiff, 0.24, 0.4, false, 0, Size(640, 640));
testYOLOModel(model_file, ref.rowRange(0, N0), scoreDiff, iouDiff, 0.5, 0.4, false, 0, Size(416, 416));
}
{
SCOPED_TRACE("batch size 2");
testYOLOModel(model_file, ref, scoreDiff, iouDiff, 0.5, 0.4, false, 0, Size(416, 416));
}
}
modules/dnn/test/test_model.cpp
+48 -22
View File
@@ -332,26 +332,19 @@ TEST_P(Test_Model, YOLOv3)
if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_MYRIAD)
applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
// The in-graph YOLO decode (Split) is not evaluable by the OpenVINO backend.
if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
std::string model_file = _tf("yolov3.onnx", false);
std::string img_path = _tf("dog416.png"); // Matches standard YOLO inference classes
checkBackend();
// Extracted from original flat ref_ array: batchId, classId, confidence, left, top, right, bottom
std::vector<int> refClassIds = {7, 16, 1};
std::vector<float> refConfidences = {0.606292f, 0.55195f, 0.433444f};
// Rect2d requires (x, y, width, height) format
std::vector<int> refClassIds = {16, 1, 7};
std::vector<float> refConfidences = {0.998835f, 0.987915f, 0.952998f};
std::vector<Rect2d> refBoxes = {
Rect2d(0.612037f, 0.149921f, 0.910763f - 0.612037f, 0.300503f - 0.149921f), // Class 7
Rect2d(0.170690f, 0.356024f, 0.471459f - 0.170690f, 0.877178f - 0.356024f), // Class 16
Rect2d(0.199235f, 0.301175f, 0.753253f - 0.199235f, 0.744156f - 0.301175f) // Class 1
Rect2d(0.160018f, 0.389962f, 0.257871f, 0.553753f),
Rect2d(0.150904f, 0.221934f, 0.591361f, 0.524322f),
Rect2d(0.614625f, 0.150259f, 0.286741f, 0.138992f),
};
// Setting precision tolerances
double scoreDiff = 8e-5, iouDiff = 3e-4;
if (target == DNN_TARGET_OPENCL_FP16 || target == DNN_TARGET_MYRIAD || target == DNN_TARGET_CPU_FP16)
{
@@ -364,16 +357,49 @@ TEST_P(Test_Model, YOLOv3)
iouDiff = 0.03;
}
// Model parameters
double confThreshold = 0.24;
double nmsThreshold = 0.4;
Size size{640, 640};
double scale = 1.0 / 255.0; // Standard image scaling for YOLO models
Scalar mean = Scalar();
bool swapRB = true; // YOLO expects RGB
const float confThreshold = 0.5f, nmsThreshold = 0.4f;
const Size inputSize(416, 416);
testDetectModel(model_file, "", img_path, refClassIds, refConfidences, refBoxes,
scoreDiff, iouDiff, confThreshold, nmsThreshold, size, mean, scale, swapRB);
Mat img = imread(_tf("dog416.png"));
cv::resize(img, img, inputSize);
Mat blob = blobFromImage(img, 1.0 / 255.0, inputSize, Scalar(), true, false);
Net net = readNet(_tf("yolov3.onnx", false));
net.setPreferableBackend(backend);
net.setPreferableTarget(target);
net.setInput(blob);
std::vector<Mat> outs;
net.forward(outs, net.getUnconnectedOutLayersNames());
int numBoxes = (int)(outs[0].total() / 4);
Mat boxesMat = outs[0].reshape(1, numBoxes);
Mat confsMat = outs[1].reshape(1, numBoxes);
std::vector<Rect2d> boxes;
std::vector<float> confidences;
std::vector<int> classIds;
for (int j = 0; j < numBoxes; ++j)
{
Mat scores = confsMat.row(j);
double confidence; Point maxLoc;
minMaxLoc(scores, 0, &confidence, 0, &maxLoc);
if (confidence >= confThreshold)
{
float* b = boxesMat.ptr<float>(j);
boxes.emplace_back(b[0], b[1], b[2] - b[0], b[3] - b[1]);
confidences.push_back((float)confidence);
classIds.push_back(maxLoc.x);
}
}
std::vector<int> keep;
NMSBoxes(boxes, confidences, confThreshold, nmsThreshold, keep);
std::vector<Rect2d> nmsBoxes; std::vector<float> nmsConfs; std::vector<int> nmsCls;
for (int k : keep) { nmsBoxes.push_back(boxes[k]); nmsConfs.push_back(confidences[k]); nmsCls.push_back(classIds[k]); }
normAssertDetections(refClassIds, refConfidences, refBoxes,
nmsCls, nmsConfs, nmsBoxes, "", confThreshold, scoreDiff, iouDiff);
}
TEST_P(Test_Model, Keypoints_pose)