TEST(Reproducibility_GoogLeNet_fp16, Accuracy) { const float l1 = 1e-5; const float lInf = 3e-3; const string proto = findDataFile("dnn/bvlc_googlenet.prototxt", false); const string model = findDataFile("dnn/bvlc_googlenet.caffemodel", false); shrinkCaffeModel(model, "bvlc_googlenet.caffemodel_fp16"); Net net = readNetFromCaffe(proto, "bvlc_googlenet.caffemodel_fp16"); std::vector<Mat> inpMats; inpMats.push_back( imread(_tf("googlenet_0.png")) ); inpMats.push_back( imread(_tf("googlenet_1.png")) ); ASSERT_TRUE(!inpMats[0].empty() && !inpMats[1].empty()); net.setInput(blobFromImages(inpMats, 1.0f, Size(), Scalar(), false), "data"); Mat out = net.forward("prob"); Mat ref = blobFromNPY(_tf("googlenet_prob.npy")); normAssert(out, ref, "", l1, lInf); }
// Test object detection network from Darknet framework. void testDarknetModel(const std::string& cfg, const std::string& weights, const std::vector<std::vector<int> >& refClassIds, const std::vector<std::vector<float> >& refConfidences, const std::vector<std::vector<Rect2d> >& refBoxes, double scoreDiff, double iouDiff, float confThreshold = 0.24, float nmsThreshold = 0.4) { checkBackend(); Mat img1 = imread(_tf("dog416.png")); Mat img2 = imread(_tf("street.png")); std::vector<Mat> samples(2); samples[0] = img1; samples[1] = img2; // determine test type, whether batch or single img int batch_size = refClassIds.size(); CV_Assert(batch_size == 1 || batch_size == 2); samples.resize(batch_size); Mat inp = blobFromImages(samples, 1.0/255, Size(416, 416), Scalar(), true, false); Net net = readNet(findDataFile("dnn/" + cfg, false), findDataFile("dnn/" + weights, false)); net.setPreferableBackend(backend); net.setPreferableTarget(target); net.setInput(inp); std::vector<Mat> outs; net.forward(outs, getOutputsNames(net)); for (int b = 0; b < batch_size; ++b) { std::vector<int> classIds; std::vector<float> confidences; std::vector<Rect2d> boxes; for (int i = 0; i < outs.size(); ++i) { Mat out; if (batch_size > 1){ // get the sample slice from 3D matrix (batch, box, classes+5) 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) { Mat scores = out.row(j).colRange(5, out.cols); double confidence; Point maxLoc; minMaxLoc(scores, 0, &confidence, 0, &maxLoc); 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; NMSBoxes(boxes, confidences, confThreshold, nmsThreshold, indices); std::vector<int> nms_classIds; std::vector<float> nms_confidences; std::vector<Rect2d> nms_boxes; for (size_t i = 0; i < indices.size(); ++i) { int idx = indices[i]; Rect2d box = boxes[idx]; float conf = confidences[idx]; int class_id = classIds[idx]; nms_boxes.push_back(box); nms_confidences.push_back(conf); nms_classIds.push_back(class_id); } normAssertDetections(refClassIds[b], refConfidences[b], refBoxes[b], nms_classIds, nms_confidences, nms_boxes, format("batch size %d, sample %d\n", batch_size, b).c_str(), confThreshold, scoreDiff, iouDiff); } }
TEST_P(Test_ONNX_nets, Googlenet) { if (backend == DNN_BACKEND_INFERENCE_ENGINE) throw SkipTestException(""); const String model = _tf("models/googlenet.onnx"); Net net = readNetFromONNX(model); ASSERT_FALSE(net.empty()); net.setPreferableBackend(backend); net.setPreferableTarget(target); std::vector<Mat> images; images.push_back( imread(_tf("../googlenet_0.png")) ); images.push_back( imread(_tf("../googlenet_1.png")) ); Mat inp = blobFromImages(images, 1.0f, Size(), Scalar(), false); Mat ref = blobFromNPY(_tf("../googlenet_prob.npy")); checkBackend(&inp, &ref); net.setInput(inp); ASSERT_FALSE(net.empty()); Mat out = net.forward(); normAssert(ref, out, "", default_l1, default_lInf); expectNoFallbacksFromIE(net); }
TEST_P(Reproducibility_MobileNet_SSD, Accuracy) { const string proto = findDataFile("dnn/MobileNetSSD_deploy.prototxt", false); const string model = findDataFile("dnn/MobileNetSSD_deploy.caffemodel", false); Net net = readNetFromCaffe(proto, model); int targetId = GetParam(); const float l1 = (targetId == DNN_TARGET_OPENCL_FP16) ? 1.5e-4 : 1e-5; const float lInf = (targetId == DNN_TARGET_OPENCL_FP16) ? 4e-4 : 1e-4; net.setPreferableTarget(targetId); Mat sample = imread(_tf("street.png")); Mat inp = blobFromImage(sample, 1.0f / 127.5, Size(300, 300), Scalar(127.5, 127.5, 127.5), false); net.setInput(inp); Mat out = net.forward(); const float scores_diff = (targetId == DNN_TARGET_OPENCL_FP16) ? 4e-4 : 1e-5; const float boxes_iou_diff = (targetId == DNN_TARGET_OPENCL_FP16) ? 5e-3 : 1e-4; Mat ref = blobFromNPY(_tf("mobilenet_ssd_caffe_out.npy")); normAssertDetections(ref, out, "", 0.0, scores_diff, boxes_iou_diff); // Check that detections aren't preserved. inp.setTo(0.0f); net.setInput(inp); out = net.forward(); out = out.reshape(1, out.total() / 7); const int numDetections = out.rows; ASSERT_NE(numDetections, 0); for (int i = 0; i < numDetections; ++i) { float confidence = out.ptr<float>(i)[2]; ASSERT_EQ(confidence, 0); } // Check batching mode. ref = ref.reshape(1, numDetections); inp = blobFromImages(std::vector<Mat>(2, sample), 1.0f / 127.5, Size(300, 300), Scalar(127.5, 127.5, 127.5), false); net.setInput(inp); Mat outBatch = net.forward(); // Output blob has a shape 1x1x2Nx7 where N is a number of detection for // a single sample in batch. The first numbers of detection vectors are batch id. outBatch = outBatch.reshape(1, outBatch.total() / 7); EXPECT_EQ(outBatch.rows, 2 * numDetections); normAssert(outBatch.rowRange(0, numDetections), ref, "", l1, lInf); normAssert(outBatch.rowRange(numDetections, 2 * numDetections).colRange(1, 7), ref.colRange(1, 7), "", l1, lInf); }