static void runTorchNet(String prefix, int targetId = DNN_TARGET_CPU, String outLayerName = "", bool check2ndBlob = false, bool isBinary = false) { String suffix = (isBinary) ? ".dat" : ".txt"; Net net = readNetFromTorch(_tf(prefix + "_net" + suffix), isBinary); ASSERT_FALSE(net.empty()); net.setPreferableBackend(DNN_BACKEND_DEFAULT); net.setPreferableTarget(targetId); Mat inp, outRef; ASSERT_NO_THROW( inp = readTorchBlob(_tf(prefix + "_input" + suffix), isBinary) ); ASSERT_NO_THROW( outRef = readTorchBlob(_tf(prefix + "_output" + suffix), isBinary) ); if (outLayerName.empty()) outLayerName = net.getLayerNames().back(); net.setInput(inp, "0"); std::vector<Mat> outBlobs; net.forward(outBlobs, outLayerName); normAssert(outRef, outBlobs[0]); if (check2ndBlob) { Mat out2 = outBlobs[1]; Mat ref2 = readTorchBlob(_tf(prefix + "_output_2" + suffix), isBinary); normAssert(out2, ref2); } }
TEST_P(Test_Torch_nets, ENet_accuracy) { Net net; { const string model = findDataFile("dnn/Enet-model-best.net", false); net = readNetFromTorch(model, true); ASSERT_TRUE(!net.empty()); } net.setPreferableTarget(GetParam()); Mat sample = imread(_tf("street.png", false)); Mat inputBlob = blobFromImage(sample, 1./255); net.setInput(inputBlob, ""); Mat out = net.forward(); Mat ref = blobFromNPY(_tf("torch_enet_prob.npy", false)); // Due to numerical instability in Pooling-Unpooling layers (indexes jittering) // thresholds for ENet must be changed. Accuracy of results was checked on // Cityscapes dataset and difference in mIOU with Torch is 10E-4% normAssert(ref, out, "", 0.00044, 0.44); const int N = 3; for (int i = 0; i < N; i++) { net.setInput(inputBlob, ""); Mat out = net.forward(); normAssert(ref, out, "", 0.00044, 0.44); } }
TEST_P(Reproducibility_SqueezeNet_v1_1, Accuracy) { Net net = readNetFromCaffe(findDataFile("dnn/squeezenet_v1.1.prototxt", false), findDataFile("dnn/squeezenet_v1.1.caffemodel", false)); int targetId = GetParam(); net.setPreferableTarget(targetId); Mat input = blobFromImage(imread(_tf("googlenet_0.png")), 1.0f, Size(227,227), Scalar(), false); ASSERT_TRUE(!input.empty()); Mat out; if (targetId == DNN_TARGET_OPENCL) { // Firstly set a wrong input blob and run the model to receive a wrong output. // Then set a correct input blob to check CPU->GPU synchronization is working well. net.setInput(input * 2.0f); out = net.forward(); } net.setInput(input); out = net.forward(); Mat ref = blobFromNPY(_tf("squeezenet_v1.1_prob.npy")); normAssert(ref, out); }
TEST_P(Reproducibility_ResNet50, Accuracy) { Net net = readNetFromCaffe(findDataFile("dnn/ResNet-50-deploy.prototxt", false), findDataFile("dnn/ResNet-50-model.caffemodel", false)); int targetId = GetParam(); net.setPreferableTarget(targetId); float l1 = (targetId == DNN_TARGET_OPENCL_FP16) ? 3e-5 : 1e-5; float lInf = (targetId == DNN_TARGET_OPENCL_FP16) ? 6e-3 : 1e-4; Mat input = blobFromImage(imread(_tf("googlenet_0.png")), 1.0f, Size(224,224), Scalar(), false); ASSERT_TRUE(!input.empty()); net.setInput(input); Mat out = net.forward(); Mat ref = blobFromNPY(_tf("resnet50_prob.npy")); normAssert(ref, out, "", l1, lInf); if (targetId == DNN_TARGET_OPENCL || targetId == DNN_TARGET_OPENCL_FP16) { UMat out_umat; net.forward(out_umat); normAssert(ref, out_umat, "out_umat", l1, lInf); std::vector<UMat> out_umats; net.forward(out_umats); normAssert(ref, out_umats[0], "out_umat_vector", l1, lInf); } }
void runTorchNet(const String& prefix, String outLayerName = "", bool check2ndBlob = false, bool isBinary = false, double l1 = 0.0, double lInf = 0.0) { String suffix = (isBinary) ? ".dat" : ".txt"; Mat inp, outRef; ASSERT_NO_THROW( inp = readTorchBlob(_tf(prefix + "_input" + suffix), isBinary) ); ASSERT_NO_THROW( outRef = readTorchBlob(_tf(prefix + "_output" + suffix), isBinary) ); checkBackend(backend, target, &inp, &outRef); Net net = readNetFromTorch(_tf(prefix + "_net" + suffix), isBinary); ASSERT_FALSE(net.empty()); net.setPreferableBackend(backend); net.setPreferableTarget(target); if (outLayerName.empty()) outLayerName = net.getLayerNames().back(); net.setInput(inp); std::vector<Mat> outBlobs; net.forward(outBlobs, outLayerName); l1 = l1 ? l1 : default_l1; lInf = lInf ? lInf : default_lInf; normAssert(outRef, outBlobs[0], "", l1, lInf); if (check2ndBlob && backend != DNN_BACKEND_INFERENCE_ENGINE) { Mat out2 = outBlobs[1]; Mat ref2 = readTorchBlob(_tf(prefix + "_output_2" + suffix), isBinary); normAssert(out2, ref2, "", l1, lInf); } }
TEST(Reproducibility_FCN, Accuracy) { Net net; { const string proto = findDataFile("dnn/fcn8s-heavy-pascal.prototxt", false); const string model = findDataFile("dnn/fcn8s-heavy-pascal.caffemodel", false); net = readNetFromCaffe(proto, model); ASSERT_FALSE(net.empty()); } Mat sample = imread(_tf("street.png")); ASSERT_TRUE(!sample.empty()); std::vector<int> layerIds; std::vector<size_t> weights, blobs; net.getMemoryConsumption(shape(1,3,227,227), layerIds, weights, blobs); net.setInput(blobFromImage(sample, 1.0f, Size(500, 500), Scalar(), false), "data"); Mat out = net.forward("score"); Mat refData = imread(_tf("caffe_fcn8s_prob.png"), IMREAD_ANYDEPTH); int shape[] = {1, 21, 500, 500}; Mat ref(4, shape, CV_32FC1, refData.data); normAssert(ref, out); }
TEST(Reproducibility_DenseNet_121, Accuracy) { const string proto = findDataFile("dnn/DenseNet_121.prototxt", false); const string model = findDataFile("dnn/DenseNet_121.caffemodel", false); Mat inp = imread(_tf("dog416.png")); inp = blobFromImage(inp, 1.0 / 255, Size(224, 224)); Mat ref = blobFromNPY(_tf("densenet_121_output.npy")); Net net = readNetFromCaffe(proto, model); net.setInput(inp); Mat out = net.forward(); normAssert(out, ref); }
TEST(Test_Darknet, read_yolo_voc_stream) { Mat ref; Mat sample = imread(_tf("dog416.png")); Mat inp = blobFromImage(sample, 1.0/255, Size(416, 416), Scalar(), true, false); const std::string cfgFile = findDataFile("dnn/yolo-voc.cfg", false); const std::string weightsFile = findDataFile("dnn/yolo-voc.weights", false); // Import by paths. { Net net = readNetFromDarknet(cfgFile, weightsFile); net.setInput(inp); net.setPreferableBackend(DNN_BACKEND_OPENCV); ref = net.forward(); } // Import from bytes array. { std::string cfg, weights; readFileInMemory(cfgFile, cfg); readFileInMemory(weightsFile, weights); Net net = readNetFromDarknet(&cfg[0], cfg.size(), &weights[0], weights.size()); net.setInput(inp); net.setPreferableBackend(DNN_BACKEND_OPENCV); Mat out = net.forward(); normAssert(ref, out); } }
TEST_P(Test_Torch_nets, OpenFace_accuracy) { #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_RELEASE < 2018030000 if (backend == DNN_BACKEND_INFERENCE_ENGINE && target == DNN_TARGET_MYRIAD) throw SkipTestException("Test is enabled starts from OpenVINO 2018R3"); #endif checkBackend(); if (backend == DNN_BACKEND_INFERENCE_ENGINE && target == DNN_TARGET_OPENCL_FP16) throw SkipTestException(""); const string model = findDataFile("dnn/openface_nn4.small2.v1.t7", false); Net net = readNetFromTorch(model); net.setPreferableBackend(backend); net.setPreferableTarget(target); Mat sample = imread(findDataFile("cv/shared/lena.png", false)); Mat sampleF32(sample.size(), CV_32FC3); sample.convertTo(sampleF32, sampleF32.type()); sampleF32 /= 255; resize(sampleF32, sampleF32, Size(96, 96), 0, 0, INTER_NEAREST); Mat inputBlob = blobFromImage(sampleF32, 1.0, Size(), Scalar(), /*swapRB*/true); net.setInput(inputBlob); Mat out = net.forward(); Mat outRef = readTorchBlob(_tf("net_openface_output.dat"), true); normAssert(out, outRef, "", default_l1, default_lInf); }
void testONNXModels(const String& basename, const Extension ext = npy, const double l1 = 0, const float lInf = 0, const bool useSoftmax = false, bool checkNoFallbacks = true) { String onnxmodel = _tf("models/" + basename + ".onnx"); Mat inp, ref; if (ext == npy) { inp = blobFromNPY(_tf("data/input_" + basename + ".npy")); ref = blobFromNPY(_tf("data/output_" + basename + ".npy")); } else if (ext == pb) { inp = readTensorFromONNX(_tf("data/input_" + basename + ".pb")); ref = readTensorFromONNX(_tf("data/output_" + basename + ".pb")); } else CV_Error(Error::StsUnsupportedFormat, "Unsupported extension"); checkBackend(&inp, &ref); Net net = readNetFromONNX(onnxmodel); ASSERT_FALSE(net.empty()); net.setPreferableBackend(backend); net.setPreferableTarget(target); net.setInput(inp); Mat out = net.forward(""); if (useSoftmax) { LayerParams lp; Net netSoftmax; netSoftmax.addLayerToPrev("softmaxLayer", "SoftMax", lp); netSoftmax.setPreferableBackend(DNN_BACKEND_OPENCV); netSoftmax.setInput(out); out = netSoftmax.forward(); netSoftmax.setInput(ref); ref = netSoftmax.forward(); } normAssert(ref, out, "", l1 ? l1 : default_l1, lInf ? lInf : default_lInf); if (checkNoFallbacks) expectNoFallbacksFromIE(net); }
TEST(Test_TensorFlow, inception_accuracy) { Net net; { const string model = findDataFile("dnn/tensorflow_inception_graph.pb", false); net = readNetFromTensorflow(model); ASSERT_FALSE(net.empty()); } Mat sample = imread(_tf("grace_hopper_227.png")); ASSERT_TRUE(!sample.empty()); resize(sample, sample, Size(224, 224)); Mat inputBlob = blobFromImage(sample); net.setInput(inputBlob, "input"); Mat out = net.forward("softmax2"); Mat ref = blobFromNPY(_tf("tf_inception_prob.npy")); normAssert(ref, out); }
// https://github.com/richzhang/colorization TEST(Reproducibility_Colorization, Accuracy) { const float l1 = 3e-5; const float lInf = 3e-3; Mat inp = blobFromNPY(_tf("colorization_inp.npy")); Mat ref = blobFromNPY(_tf("colorization_out.npy")); Mat kernel = blobFromNPY(_tf("colorization_pts_in_hull.npy")); const string proto = findDataFile("dnn/colorization_deploy_v2.prototxt", false); const string model = findDataFile("dnn/colorization_release_v2.caffemodel", false); Net net = readNetFromCaffe(proto, model); net.getLayer(net.getLayerId("class8_ab"))->blobs.push_back(kernel); net.getLayer(net.getLayerId("conv8_313_rh"))->blobs.push_back(Mat(1, 313, CV_32F, 2.606)); net.setInput(inp); Mat out = net.forward(); normAssert(out, ref, "", l1, lInf); }
TEST(Test_TensorFlow, inception_accuracy) { Net net; { const string model = findDataFile("dnn/tensorflow_inception_graph.pb", false); net = readNetFromTensorflow(model); ASSERT_FALSE(net.empty()); } net.setPreferableBackend(DNN_BACKEND_OPENCV); Mat sample = imread(_tf("grace_hopper_227.png")); ASSERT_TRUE(!sample.empty()); Mat inputBlob = blobFromImage(sample, 1.0, Size(224, 224), Scalar(), /*swapRB*/true); net.setInput(inputBlob, "input"); Mat out = net.forward("softmax2"); Mat ref = blobFromNPY(_tf("tf_inception_prob.npy")); normAssert(ref, out); }
TEST_P(Test_ONNX_nets, Alexnet) { applyTestTag(target == DNN_TARGET_CPU ? CV_TEST_TAG_MEMORY_512MB : CV_TEST_TAG_MEMORY_1GB); const String model = _tf("models/alexnet.onnx"); Net net = readNetFromONNX(model); ASSERT_FALSE(net.empty()); net.setPreferableBackend(backend); net.setPreferableTarget(target); Mat inp = imread(_tf("../grace_hopper_227.png")); Mat ref = blobFromNPY(_tf("../caffe_alexnet_prob.npy")); checkBackend(&inp, &ref); net.setInput(blobFromImage(inp, 1.0f, Size(227, 227), Scalar(), false)); ASSERT_FALSE(net.empty()); Mat out = net.forward(); normAssert(out, ref, "", default_l1, default_lInf); expectNoFallbacksFromIE(net); }
TEST_P(Test_ONNX_layers, MultyInputs) { const String model = _tf("models/multy_inputs.onnx"); Net net = readNetFromONNX(model); ASSERT_FALSE(net.empty()); net.setPreferableBackend(backend); net.setPreferableTarget(target); Mat inp1 = blobFromNPY(_tf("data/input_multy_inputs_0.npy")); Mat inp2 = blobFromNPY(_tf("data/input_multy_inputs_1.npy")); Mat ref = blobFromNPY(_tf("data/output_multy_inputs.npy")); checkBackend(&inp1, &ref); net.setInput(inp1, "0"); net.setInput(inp2, "1"); Mat out = net.forward(); normAssert(ref, out, "", default_l1, default_lInf); expectNoFallbacksFromIE(net); }
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_P(Test_Torch_nets, ENet_accuracy) { checkBackend(); if (backend == DNN_BACKEND_INFERENCE_ENGINE || (backend == DNN_BACKEND_OPENCV && target == DNN_TARGET_OPENCL_FP16)) throw SkipTestException(""); Net net; { const string model = findDataFile("dnn/Enet-model-best.net", false); net = readNetFromTorch(model, true); ASSERT_TRUE(!net.empty()); } net.setPreferableBackend(backend); net.setPreferableTarget(target); Mat sample = imread(_tf("street.png", false)); Mat inputBlob = blobFromImage(sample, 1./255, Size(), Scalar(), /*swapRB*/true); net.setInput(inputBlob, ""); Mat out = net.forward(); Mat ref = blobFromNPY(_tf("torch_enet_prob.npy", false)); // Due to numerical instability in Pooling-Unpooling layers (indexes jittering) // thresholds for ENet must be changed. Accuracy of results was checked on // Cityscapes dataset and difference in mIOU with Torch is 10E-4% normAssert(ref, out, "", 0.00044, /*target == DNN_TARGET_CPU ? 0.453 : */0.552); normAssertSegmentation(ref, out); const int N = 3; for (int i = 0; i < N; i++) { net.setInput(inputBlob, ""); Mat out = net.forward(); normAssert(ref, out, "", 0.00044, /*target == DNN_TARGET_CPU ? 0.453 : */0.552); normAssertSegmentation(ref, out); } }
TEST(Reproducibility_SSD, Accuracy) { Net net; { const string proto = findDataFile("dnn/ssd_vgg16.prototxt", false); const string model = findDataFile("dnn/VGG_ILSVRC2016_SSD_300x300_iter_440000.caffemodel", false); net = readNetFromCaffe(proto, model); ASSERT_FALSE(net.empty()); } Mat sample = imread(_tf("street.png")); ASSERT_TRUE(!sample.empty()); if (sample.channels() == 4) cvtColor(sample, sample, COLOR_BGRA2BGR); Mat in_blob = blobFromImage(sample, 1.0f, Size(300, 300), Scalar(), false); net.setInput(in_blob, "data"); Mat out = net.forward("detection_out"); Mat ref = blobFromNPY(_tf("ssd_out.npy")); normAssertDetections(ref, out); }
TEST_P(Reproducibility_AlexNet, Accuracy) { bool readFromMemory = get<0>(GetParam()); Net net; { const string proto = findDataFile("dnn/bvlc_alexnet.prototxt", false); const string model = findDataFile("dnn/bvlc_alexnet.caffemodel", false); if (readFromMemory) { string dataProto; ASSERT_TRUE(readFileInMemory(proto, dataProto)); string dataModel; ASSERT_TRUE(readFileInMemory(model, dataModel)); net = readNetFromCaffe(dataProto.c_str(), dataProto.size(), dataModel.c_str(), dataModel.size()); } else net = readNetFromCaffe(proto, model); ASSERT_FALSE(net.empty()); } int targetId = get<1>(GetParam()); const float l1 = 1e-5; const float lInf = (targetId == DNN_TARGET_OPENCL_FP16) ? 3e-3 : 1e-4; net.setPreferableTarget(targetId); Mat sample = imread(_tf("grace_hopper_227.png")); ASSERT_TRUE(!sample.empty()); net.setInput(blobFromImage(sample, 1.0f, Size(227, 227), Scalar(), false), "data"); Mat out = net.forward("prob"); Mat ref = blobFromNPY(_tf("caffe_alexnet_prob.npy")); normAssert(ref, out, "", l1, lInf); }
TEST_P(Test_Torch_nets, OpenFace_accuracy) { const string model = findDataFile("dnn/openface_nn4.small2.v1.t7", false); Net net = readNetFromTorch(model); net.setPreferableTarget(GetParam()); Mat sample = imread(findDataFile("cv/shared/lena.png", false)); Mat sampleF32(sample.size(), CV_32FC3); sample.convertTo(sampleF32, sampleF32.type()); sampleF32 /= 255; resize(sampleF32, sampleF32, Size(96, 96), 0, 0, INTER_NEAREST); Mat inputBlob = blobFromImage(sampleF32); net.setInput(inputBlob); Mat out = net.forward(); Mat outRef = readTorchBlob(_tf("net_openface_output.dat"), true); normAssert(out, outRef); }
TEST(Test_TensorFlow, read_inception) { Net net; { const string model = findDataFile("dnn/tensorflow_inception_graph.pb", false); net = readNetFromTensorflow(model); ASSERT_FALSE(net.empty()); } Mat sample = imread(_tf("grace_hopper_227.png")); ASSERT_TRUE(!sample.empty()); Mat input; resize(sample, input, Size(224, 224)); input -= 128; // mean sub Mat inputBlob = blobFromImage(input); net.setInput(inputBlob, "input"); Mat out = net.forward("softmax2"); std::cout << out.dims << std::endl; }
TEST(Test_Caffe, read_googlenet) { Net net = readNetFromCaffe(_tf("bvlc_googlenet.prototxt")); ASSERT_FALSE(net.empty()); }
TEST(Torch_Importer, simple_read) { Net net; ASSERT_NO_THROW(net = readNetFromTorch(_tf("net_simple_net.txt"), false)); ASSERT_FALSE(net.empty()); }
TEST(Test_Caffe, read_gtsrb) { Net net = readNetFromCaffe(_tf("gtsrb.prototxt")); ASSERT_FALSE(net.empty()); }
// 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(Test_Darknet, read_yolo_voc) { Net net = readNetFromDarknet(_tf("yolo-voc.cfg")); ASSERT_FALSE(net.empty()); }
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); }