modules/dnn/test/test_onnx_importer.cpp

   1 // This file is part of OpenCV project.
   2 // It is subject to the license terms in the LICENSE file found in the top-level directory
   3 // of this distribution and at http://opencv.org/license.html.
   4
   5 // Copyright (C) 2018-2019, Intel Corporation, all rights reserved.
   6 // Third party copyrights are property of their respective owners.
   7
   8
   9 #include "test_precomp.hpp"
  10 #include "npy_blob.hpp"
  11 #include <opencv2/dnn/shape_utils.hpp>
  12 namespace opencv_test { namespace {
  13
  14 template<typename TString>
  15 static std::string _tf(TString filename, bool required = true)
  16 {
  17     return findDataFile(std::string("dnn/onnx/") + filename, required);
  18 }
  19
  20 class Test_ONNX_layers : public DNNTestLayer
  21 {
  22 public:
  23     bool required;
  24
  25     Test_ONNX_layers() : required(true) { }
  26
  27     enum Extension
  28     {
  29         npy,
  30         pb
  31     };
  32
  33     void testONNXModels(const String& basename, const Extension ext = npy,
  34                         const double l1 = 0, const float lInf = 0, const bool useSoftmax = false,
  35                         bool checkNoFallbacks = true, int numInps = 1)
  36     {
  37         String onnxmodel = _tf("models/" + basename + ".onnx", required);
  38         std::vector<Mat> inps(numInps);
  39         Mat ref;
  40         if (ext == npy) {
  41             for (int i = 0; i < numInps; ++i)
  42                 inps[i] = blobFromNPY(_tf("data/input_" + basename + (numInps > 1 ? format("_%d", i) : "") + ".npy"));
  43             ref = blobFromNPY(_tf("data/output_" + basename + ".npy"));
  44         }
  45         else if (ext == pb) {
  46             for (int i = 0; i < numInps; ++i)
  47                 inps[i] = readTensorFromONNX(_tf("data/input_" + basename + (numInps > 1 ? format("_%d", i) : "") + ".pb"));
  48             ref = readTensorFromONNX(_tf("data/output_" + basename + ".pb"));
  49         }
  50         else
  51             CV_Error(Error::StsUnsupportedFormat, "Unsupported extension");
  52
  53         checkBackend(&inps[0], &ref);
  54         Net net = readNetFromONNX(onnxmodel);
  55         ASSERT_FALSE(net.empty());
  56
  57         net.setPreferableBackend(backend);
  58         net.setPreferableTarget(target);
  59
  60         std::vector<String> inputNames;
  61         for (int i = 0; i < numInps; ++i)
  62             inputNames.push_back(format("%d", i));
  63         net.setInputsNames(inputNames);
  64
  65         for (int i = 0; i < numInps; ++i)
  66             net.setInput(inps[i], inputNames[i]);
  67         Mat out = net.forward("");
  68
  69         if (useSoftmax)
  70         {
  71             LayerParams lp;
  72             Net netSoftmax;
  73             netSoftmax.addLayerToPrev("softmaxLayer", "Softmax", lp);
  74             netSoftmax.setPreferableBackend(DNN_BACKEND_OPENCV);
  75
  76             netSoftmax.setInput(out);
  77             out = netSoftmax.forward();
  78
  79             netSoftmax.setInput(ref);
  80             ref = netSoftmax.forward();
  81         }
  82         normAssert(ref, out, "", l1 ? l1 : default_l1, lInf ? lInf : default_lInf);
  83         if (checkNoFallbacks)
  84             expectNoFallbacksFromIE(net);
  85     }
  86 };
  87
  88 TEST_P(Test_ONNX_layers, InstanceNorm)
  89 {
  90     if(backend == DNN_BACKEND_CUDA)
  91         applyTestTag(CV_TEST_TAG_DNN_SKIP_CUDA); /* MVN is not supported */
  92
  93     if (target == DNN_TARGET_MYRIAD)
  94         testONNXModels("instancenorm", npy, 0, 0, false, false);
  95     else
  96         testONNXModels("instancenorm", npy);
  97 }
  98
  99 TEST_P(Test_ONNX_layers, MaxPooling)
 100 {
 101 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_GE(2020020000)
 102     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_MYRIAD)
 103         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
 104 #endif
 105     testONNXModels("maxpooling", npy, 0, 0, false, false);
 106 }
 107 TEST_P(Test_ONNX_layers, MaxPooling_2)
 108 {
 109 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2022010000)
 110     // IE exception: Cannot get memory!
 111     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_CPU)
 112         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_CPU, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
 113 #endif
 114
 115     testONNXModels("two_maxpooling", npy, 0, 0, false, false);
 116 }
 117
 118 TEST_P(Test_ONNX_layers, Convolution)
 119 {
 120     testONNXModels("convolution");
 121     testONNXModels("conv_asymmetric_pads");
 122 }
 123
 124 TEST_P(Test_ONNX_layers, Convolution_variable_weight)
 125 {
 126     if ((backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH ||
 127          backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019) && target == DNN_TARGET_MYRIAD)
 128         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
 129
 130     if (backend == DNN_BACKEND_CUDA)
 131         applyTestTag(CV_TEST_TAG_DNN_SKIP_CUDA); // not supported
 132     if (backend == DNN_BACKEND_VKCOM)
 133         applyTestTag(CV_TEST_TAG_DNN_SKIP_VULKAN); // not supported
 134     String basename = "conv_variable_w";
 135     Net net = readNetFromONNX(_tf("models/" + basename + ".onnx"));
 136     ASSERT_FALSE(net.empty());
 137
 138     net.setPreferableBackend(backend);
 139     net.setPreferableTarget(target);
 140
 141     for (int i = 0; i < 2; i++)
 142     {
 143         Mat input = blobFromNPY(_tf("data/input_" + basename + format("_%d", i) + "_0.npy"));
 144         Mat weights = blobFromNPY(_tf("data/input_" + basename + format("_%d", i) + "_1.npy"));
 145         Mat ref = blobFromNPY(_tf("data/output_" + basename + format("_%d", i) + ".npy"));
 146
 147         net.setInput(input, "0");
 148         net.setInput(weights, "1");
 149
 150         Mat out = net.forward();
 151         normAssert(ref, out, "", default_l1, default_lInf);
 152     }
 153 }
 154
 155 TEST_P(Test_ONNX_layers, Convolution_variable_weight_bias)
 156 {
 157 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2022010000)
 158     // openvino/src/plugins/intel_myriad/common/src/ngraph/transformations/extract_dynamic_batch/slice_convolution.cpp:14 Expecting operation v1::GroupConvolution GroupConvolution_6904725 (Reshape_17[0]:f32{1,4,5,5}, Reshape_6904719[0]:f32{4,1,1,2,2}) -> (f32{1,4,4,4}) to have constant kernel, got Reshape_6904719[0]:f32{4,1,1,2,2}
 159     // openvino\src\plugins\intel_myriad\common\src\ngraph\transformations\extract_dynamic_batch\slice_convolution.cpp:15 Expecting operation v1::GroupConvolution GroupConvolution_6904692 (Reshape_17[0]:f32{1,4,5,5}, Reshape_6904686[0]:f32{4,1,1,2,2}) -> (f32{1,4,4,4}) to have constant kernel, got Reshape_6904686[0]:f32{4,1,1,2,2}
 160     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_MYRIAD)
 161         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
 162     // accuracy (depends on OpenCL version / HW)
 163     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && (target == DNN_TARGET_OPENCL || target == DNN_TARGET_OPENCL_FP16))
 164         applyTestTag(target == DNN_TARGET_OPENCL ? CV_TEST_TAG_DNN_SKIP_IE_OPENCL : CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16,
 165             CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION
 166         );
 167 #elif defined(INF_ENGINE_RELEASE)
 168     if ((backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH ||
 169          backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019) && target == DNN_TARGET_MYRIAD)
 170         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
 171
 172     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_CPU &&
 173         getInferenceEngineCPUType() == CV_DNN_INFERENCE_ENGINE_CPU_TYPE_ARM_COMPUTE)
 174         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_ARM_CPU, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
 175 #endif
 176
 177     if (backend == DNN_BACKEND_CUDA)
 178         applyTestTag(CV_TEST_TAG_DNN_SKIP_CUDA); // supports only <= 2 inputs
 179
 180     if (backend == DNN_BACKEND_VKCOM)
 181         applyTestTag(CV_TEST_TAG_DNN_SKIP_VULKAN); // not supported
 182
 183     String basename = "conv_variable_wb";
 184     Net net = readNetFromONNX(_tf("models/" + basename + ".onnx"));
 185     ASSERT_FALSE(net.empty());
 186
 187     net.setPreferableBackend(backend);
 188     net.setPreferableTarget(target);
 189
 190     for (int i = 0; i < 2; i++)
 191     {
 192         Mat input = blobFromNPY(_tf("data/input_" + basename + format("_%d", i) + "_0.npy"));
 193         Mat weights = blobFromNPY(_tf("data/input_" + basename + format("_%d", i) + "_1.npy"));
 194         Mat bias = blobFromNPY(_tf("data/input_" + basename + format("_%d", i) + "_2.npy"));
 195         Mat ref = blobFromNPY(_tf("data/output_" + basename + format("_%d", i) + ".npy"));
 196
 197         net.setInput(input, "0");
 198         net.setInput(weights, "1");
 199         net.setInput(bias, "bias");
 200
 201         Mat out = net.forward();
 202         normAssert(ref, out, "", default_l1, default_lInf);
 203     }
 204 }
 205
 206 TEST_P(Test_ONNX_layers, Gather)
 207 {
 208     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 && target == DNN_TARGET_MYRIAD)
 209         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
 210     testONNXModels("gather");
 211     // GPU plugin unsupported slice for constant
 212     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && (target == DNN_TARGET_OPENCL || target == DNN_TARGET_OPENCL_FP16))
 213         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL, CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
 214     testONNXModels("gather_scalar", npy, 0, 0, false, false);
 215 }
 216
 217 TEST_P(Test_ONNX_layers, Convolution3D)
 218 {
 219     testONNXModels("conv3d");
 220 }
 221
 222 TEST_P(Test_ONNX_layers, Convolution3D_bias)
 223 {
 224     testONNXModels("conv3d_bias");
 225 }
 226
 227 TEST_P(Test_ONNX_layers, Two_convolution)
 228 {
 229 #if defined(INF_ENGINE_RELEASE)
 230     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 && target == DNN_TARGET_MYRIAD
 231         && getInferenceEngineVPUType() == CV_DNN_INFERENCE_ENGINE_VPU_TYPE_MYRIAD_X
 232     )
 233         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD_X, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
 234 #endif
 235     // Reference output values are in range [-0.855, 0.611]
 236     testONNXModels("two_convolution");
 237 }
 238
 239 TEST_P(Test_ONNX_layers, Deconvolution)
 240 {
 241     testONNXModels("deconvolution", npy, 0, 0, false, false);
 242     testONNXModels("two_deconvolution", npy, 0, 0, false, false);
 243     testONNXModels("deconvolution_group", npy, 0, 0, false, false);
 244     testONNXModels("deconvolution_output_shape", npy, 0, 0, false, false);
 245     if (target != DNN_TARGET_CUDA_FP16) // bug
 246         testONNXModels("deconv_adjpad_2d", npy, 0, 0, false, false);
 247 }
 248
 249 TEST_P(Test_ONNX_layers, Deconvolution3D)
 250 {
 251 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2022010000)
 252     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
 253     {
 254         // [ GENERAL_ERROR ] openvino/src/plugins/intel_myriad/graph_transformer/src/frontend/frontend.cpp:592 Failed to compile layer "2":
 255         // [ GENERAL_ERROR ] openvino/src/plugins/intel_myriad/graph_transformer/src/model/model.cpp:198 duplicateData error: while duplicating 2@weights Const data got different desc and content byte sizes (162 and 486 respectively)
 256         if (target == DNN_TARGET_MYRIAD)
 257             applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
 258     }
 259 #elif defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2021040000)
 260     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
 261     {
 262         // [ GENERAL_ERROR ] vpu/graph_transformer/src/frontend/frontend.cpp:439 Failed to compile layer "2":
 263         // [ GENERAL_ERROR ] vpu/graph_transformer/src/model/model.cpp:198 duplicateData error: while duplicating 2@weights Const data got different desc and content byte sizes (162 and 486 respectively)
 264         if (target == DNN_TARGET_MYRIAD)
 265             applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
 266     }
 267 #endif
 268
 269     if (backend == DNN_BACKEND_OPENCV)
 270         throw SkipTestException("OpenCV backend is not supported");  // FIXIT use tags
 271
 272     if (backend == DNN_BACKEND_VKCOM)
 273         applyTestTag(CV_TEST_TAG_DNN_SKIP_VULKAN);
 274
 275     testONNXModels("deconv3d");
 276 }
 277
 278 TEST_P(Test_ONNX_layers, Deconvolution3D_bias)
 279 {
 280 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2022010000)
 281     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
 282     {
 283         // [ GENERAL_ERROR ] openvino/src/plugins/intel_myriad/graph_transformer/src/frontend/frontend.cpp:592 Failed to compile layer "3":
 284         // [ GENERAL_ERROR ] openvino/src/plugins/intel_myriad/graph_transformer/src/model/model.cpp:198 duplicateData error: while duplicating 3@weights Const data got different desc and content byte sizes (270 and 810 respectively)
 285         if (target == DNN_TARGET_MYRIAD)
 286             applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
 287     }
 288 #elif defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2021040000)
 289     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
 290     {
 291         // [ GENERAL_ERROR ] vpu/graph_transformer/src/frontend/frontend.cpp:439 Failed to compile layer "2":
 292         // [ GENERAL_ERROR ] vpu/graph_transformer/src/model/model.cpp:198 duplicateData error: while duplicating 2@weights Const data got different desc and content byte sizes (162 and 486 respectively)
 293         if (target == DNN_TARGET_MYRIAD)
 294             applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
 295     }
 296 #endif
 297
 298     if (backend == DNN_BACKEND_OPENCV)
 299         throw SkipTestException("OpenCV backend is not supported");  // FIXIT use tags
 300
 301     if (backend == DNN_BACKEND_VKCOM)
 302         applyTestTag(CV_TEST_TAG_DNN_SKIP_VULKAN);
 303
 304     testONNXModels("deconv3d_bias");
 305 }
 306
 307 TEST_P(Test_ONNX_layers, Deconvolution3D_pad)
 308 {
 309 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2022010000)
 310     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
 311     {
 312         // [ GENERAL_ERROR ] openvino/src/plugins/intel_myriad/graph_transformer/src/frontend/frontend.cpp:592 Failed to compile layer "3":
 313         // [ GENERAL_ERROR ] openvino/src/plugins/intel_myriad/graph_transformer/src/model/model.cpp:198 duplicateData error: while duplicating 3@weights Const data got different desc and content byte sizes (108 and 432 respectively)
 314         if (target == DNN_TARGET_MYRIAD)
 315             applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
 316     }
 317 #elif defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2021040000)
 318     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
 319     {
 320         // [ GENERAL_ERROR ] vpu/graph_transformer/src/frontend/frontend.cpp:439 Failed to compile layer "2":
 321         // [ GENERAL_ERROR ] vpu/graph_transformer/src/model/model.cpp:198 duplicateData error: while duplicating 2@weights Const data got different desc and content byte sizes (162 and 486 respectively)
 322         if (target == DNN_TARGET_MYRIAD)
 323             applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
 324     }
 325 #endif
 326
 327     if (backend == DNN_BACKEND_OPENCV)
 328         throw SkipTestException("OpenCV backend is not supported");  // FIXIT use tags
 329
 330     if (backend == DNN_BACKEND_VKCOM)
 331         applyTestTag(CV_TEST_TAG_DNN_SKIP_VULKAN);
 332
 333     testONNXModels("deconv3d_pad");
 334 }
 335
 336 TEST_P(Test_ONNX_layers, Deconvolution3D_adjpad)
 337 {
 338 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2022010000)
 339     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
 340     {
 341         // [ GENERAL_ERROR ] openvino/src/plugins/intel_myriad/graph_transformer/src/frontend/frontend.cpp:592 Failed to compile layer "3":
 342         // [ GENERAL_ERROR ] openvino/src/plugins/intel_myriad/graph_transformer/src/model/model.cpp:198 duplicateData error: while duplicating 3@weights Const data got different desc and content byte sizes (90 and 180 respectively)
 343         if (target == DNN_TARGET_MYRIAD)
 344             applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
 345     }
 346 #elif defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2021040000)
 347     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
 348     {
 349         // [ GENERAL_ERROR ] vpu/graph_transformer/src/frontend/frontend.cpp:439 Failed to compile layer "2":
 350         // [ GENERAL_ERROR ] vpu/graph_transformer/src/model/model.cpp:198 duplicateData error: while duplicating 2@weights Const data got different desc and content byte sizes (162 and 486 respectively)
 351         if (target == DNN_TARGET_MYRIAD)
 352             applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
 353     }
 354 #endif
 355
 356     if (backend == DNN_BACKEND_OPENCV)
 357         throw SkipTestException("OpenCV backend is not supported");  // FIXIT use tags
 358
 359     if (backend == DNN_BACKEND_VKCOM)
 360         applyTestTag(CV_TEST_TAG_DNN_SKIP_VULKAN);
 361
 362     testONNXModels("deconv3d_adjpad");
 363 }
 364
 365 TEST_P(Test_ONNX_layers, Dropout)
 366 {
 367     testONNXModels("dropout");
 368 }
 369
 370 TEST_P(Test_ONNX_layers, Linear)
 371 {
 372     if (backend == DNN_BACKEND_OPENCV && target == DNN_TARGET_OPENCL_FP16)
 373         applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL_FP16);
 374     testONNXModels("linear");
 375 }
 376
 377 TEST_P(Test_ONNX_layers, ReLU)
 378 {
 379     testONNXModels("ReLU");
 380 }
 381
 382 TEST_P(Test_ONNX_layers, PReLU)
 383 {
 384     testONNXModels("PReLU_slope");
 385 }
 386
 387 TEST_P(Test_ONNX_layers, Clip)
 388 {
 389     testONNXModels("clip", npy);
 390 }
 391
 392 TEST_P(Test_ONNX_layers, Clip_init)
 393 {
 394     testONNXModels("clip_init_min_max");
 395     testONNXModels("clip_init_min");
 396     testONNXModels("clip_init_max");
 397 }
 398
 399 TEST_P(Test_ONNX_layers, Shape)
 400 {
 401     testONNXModels("shape_of_constant");
 402 }
 403
 404 TEST_P(Test_ONNX_layers, ReduceMean)
 405 {
 406     testONNXModels("reduce_mean");
 407     testONNXModels("reduce_mean_axis1");
 408     testONNXModels("reduce_mean_axis2");
 409 }
 410
 411 TEST_P(Test_ONNX_layers, ReduceSum)
 412 {
 413     testONNXModels("reduce_sum");
 414     testONNXModels("reduce_sum_axis_dynamic_batch");
 415 }
 416
 417 TEST_P(Test_ONNX_layers, ReduceMax)
 418 {
 419     testONNXModels("reduce_max");
 420 }
 421 TEST_P(Test_ONNX_layers, ReduceMax_axis_0)
 422 {
 423     testONNXModels("reduce_max_axis_0");
 424 }
 425 TEST_P(Test_ONNX_layers, ReduceMax_axis_1)
 426 {
 427 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2021040000)
 428     // [ GENERAL_ERROR ]  AssertionFailed: !out.networkInputs.empty()
 429     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_MYRIAD)
 430         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
 431 #endif
 432     testONNXModels("reduce_max_axis_1");
 433 }
 434
 435 TEST_P(Test_ONNX_layers, Min)
 436 {
 437     testONNXModels("min", npy, 0, 0, false, true, 2);
 438 }
 439
 440 TEST_P(Test_ONNX_layers, ArgLayer)
 441 {
 442     if (backend != DNN_BACKEND_OPENCV || target != DNN_TARGET_CPU)
 443         throw SkipTestException("Only CPU is supported");  // FIXIT use tags
 444
 445     testONNXModels("argmax");
 446     testONNXModels("argmin");
 447 }
 448
 449 TEST_P(Test_ONNX_layers, Scale)
 450 {
 451 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2022010000)
 452     // accuracy (inf/nan)
 453     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_MYRIAD)
 454         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
 455 #elif defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2021040000)
 456     // accuracy
 457     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_MYRIAD)
 458         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
 459     // IE exception: mkldnn_node.cpp:238 Ngraph operation Reshape with name ReduceMean_0 has dynamic output shape on 0 port, but CPU plug-in supports only static shape
 460     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && (target == DNN_TARGET_OPENCL || target == DNN_TARGET_OPENCL_FP16))
 461         applyTestTag(target == DNN_TARGET_OPENCL ? CV_TEST_TAG_DNN_SKIP_IE_OPENCL : CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16,
 462             CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION
 463         );
 464 #elif defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2021040000)
 465     // Ngraph operation Reshape with name ReduceMean_0 has dynamic output shape on 0 port, but CPU plug-in supports only static shape
 466     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_OPENCL)
 467         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
 468     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_OPENCL_FP16)
 469         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
 470 #endif
 471     testONNXModels("scale");
 472 }
 473
 474 TEST_P(Test_ONNX_layers, Scale_broadcast)
 475 {
 476     if (backend == DNN_BACKEND_CUDA)
 477         applyTestTag(CV_TEST_TAG_DNN_SKIP_CUDA); // doesn't support broadcasting
 478     testONNXModels("scale_broadcast", npy, 0, 0, false, true, 3);
 479 }
 480
 481 TEST_P(Test_ONNX_layers, Scale_broadcast_mid)
 482 {
 483     if (backend == DNN_BACKEND_CUDA)
 484         applyTestTag(CV_TEST_TAG_DNN_SKIP_CUDA); // doesn't support broadcasting
 485     testONNXModels("scale_broadcast_mid", npy, 0, 0, false, true, 2);
 486 }
 487
 488 TEST_P(Test_ONNX_layers, ReduceMean3D)
 489 {
 490 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2021040000)
 491     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 && target != DNN_TARGET_CPU)
 492         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);  // Only CPU on DLIE backend is supported
 493     else if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target != DNN_TARGET_CPU)
 494         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);  // Only CPU on DLIE backend is supported
 495 #endif
 496     if (backend == DNN_BACKEND_OPENCV && target != DNN_TARGET_CPU)
 497         throw SkipTestException("Only CPU is supported");  // FIXIT use tags
 498
 499     if (backend == DNN_BACKEND_VKCOM)
 500         applyTestTag(CV_TEST_TAG_DNN_SKIP_VULKAN);
 501
 502     testONNXModels("reduce_mean3d");
 503 }
 504
 505 TEST_P(Test_ONNX_layers, MaxPooling_Sigmoid)
 506 {
 507     testONNXModels("maxpooling_sigmoid");
 508 }
 509
 510 TEST_P(Test_ONNX_layers, Cast)
 511 {
 512     testONNXModels("cast");
 513 }
 514
 515 TEST_P(Test_ONNX_layers, Power)
 516 {
 517     testONNXModels("pow2", npy, 0, 0, false, false);
 518 }
 519
 520 TEST_P(Test_ONNX_layers, Exp)
 521 {
 522     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
 523         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
 524     testONNXModels("exp");
 525 }
 526
 527 TEST_P(Test_ONNX_layers, Elementwise_Ceil)
 528 {
 529 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2021040000)
 530     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
 531         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
 532     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
 533         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
 534 #endif
 535     testONNXModels("ceil");
 536 }
 537
 538 TEST_P(Test_ONNX_layers, Elementwise_Floor)
 539 {
 540 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2021040000)
 541     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
 542         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
 543     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
 544         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
 545 #endif
 546     testONNXModels("floor");
 547 }
 548
 549 TEST_P(Test_ONNX_layers, Elementwise_Log)
 550 {
 551 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2021040000)
 552     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
 553         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
 554     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
 555         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
 556 #endif
 557     testONNXModels("log");
 558 }
 559
 560 TEST_P(Test_ONNX_layers, Elementwise_Round)
 561 {
 562 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2021040000)
 563     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
 564         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
 565     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
 566         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
 567 #endif
 568     testONNXModels("round");
 569 }
 570
 571 TEST_P(Test_ONNX_layers, Elementwise_Sqrt)
 572 {
 573 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2021040000)
 574     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
 575         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
 576     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
 577         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
 578     testONNXModels("sqrt");
 579 #endif
 580 }
 581
 582 TEST_P(Test_ONNX_layers, Elementwise_not)
 583 {
 584 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2022010000)
 585     // Cannot get memory!
 586     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_CPU)
 587         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_CPU, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
 588     // Cannot get memory!
 589     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && (target == DNN_TARGET_OPENCL || target == DNN_TARGET_OPENCL_FP16))
 590         applyTestTag(target == DNN_TARGET_OPENCL ? CV_TEST_TAG_DNN_SKIP_IE_OPENCL : CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16,
 591             CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION
 592         );
 593     // Cannot get memory!
 594     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_MYRIAD)
 595         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
 596 #elif defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2021040000)
 597     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
 598         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
 599     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
 600         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
 601 #endif
 602     testONNXModels("not");
 603 }
 604
 605 TEST_P(Test_ONNX_layers, Compare_EQ)
 606 {
 607 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2022010000)
 608     // Cannot get memory!
 609     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_CPU)
 610         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_CPU, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
 611 #elif defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2021040000)
 612     // IE exception: Function contains several inputs and outputs with one friendly name!
 613     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && (target == DNN_TARGET_OPENCL || target == DNN_TARGET_OPENCL_FP16))
 614         applyTestTag(target == DNN_TARGET_OPENCL ? CV_TEST_TAG_DNN_SKIP_IE_OPENCL : CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16,
 615             CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION
 616         );
 617     // IE exception: Function contains several inputs and outputs with one friendly name!
 618     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_MYRIAD)
 619         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
 620 #elif defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2021040000)
 621     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
 622         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
 623     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
 624         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
 625 #endif
 626
 627     testONNXModels("equal");
 628 }
 629
 630 TEST_P(Test_ONNX_layers, Compare_GT)
 631 {
 632 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2022010000)
 633     // Cannot get memory!
 634     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_CPU)
 635         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_CPU, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
 636 #elif defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2021040000)
 637     // IE exception: Function contains several inputs and outputs with one friendly name!
 638     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && (target == DNN_TARGET_OPENCL || target == DNN_TARGET_OPENCL_FP16))
 639         applyTestTag(target == DNN_TARGET_OPENCL ? CV_TEST_TAG_DNN_SKIP_IE_OPENCL : CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16,
 640             CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION
 641         );
 642     // IE exception: Function contains several inputs and outputs with one friendly name!
 643     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_MYRIAD)
 644         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
 645 #elif defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2021040000)
 646     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
 647         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
 648     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
 649         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
 650 #endif
 651
 652     testONNXModels("greater");
 653 }
 654
 655 TEST_P(Test_ONNX_layers, Compare_LT)
 656 {
 657 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2022010000)
 658     // Cannot get memory!
 659     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_CPU)
 660         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_CPU, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
 661 #elif defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2021040000)
 662     // IE exception: Function contains several inputs and outputs with one friendly name!
 663     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && (target == DNN_TARGET_OPENCL || target == DNN_TARGET_OPENCL_FP16))
 664         applyTestTag(target == DNN_TARGET_OPENCL ? CV_TEST_TAG_DNN_SKIP_IE_OPENCL : CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16,
 665             CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION
 666         );
 667     // IE exception: Function contains several inputs and outputs with one friendly name!
 668     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_MYRIAD)
 669         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
 670 #elif defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2021040000)
 671     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
 672         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
 673     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
 674         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
 675 #endif
 676
 677     testONNXModels("less");
 678 }
 679
 680 TEST_P(Test_ONNX_layers, CompareSameDims_EQ)
 681 {
 682 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2022010000)
 683     // Cannot get memory!
 684     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_CPU)
 685         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_CPU, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
 686 #elif defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2021040000)
 687     // IE exception: Function contains several inputs and outputs with one friendly name!
 688     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && (target == DNN_TARGET_OPENCL || target == DNN_TARGET_OPENCL_FP16))
 689         applyTestTag(target == DNN_TARGET_OPENCL ? CV_TEST_TAG_DNN_SKIP_IE_OPENCL : CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16,
 690             CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION
 691         );
 692     // IE exception: Function contains several inputs and outputs with one friendly name!
 693     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_MYRIAD)
 694         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
 695 #elif defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2021040000)
 696     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
 697         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
 698     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
 699         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
 700 #endif
 701
 702     testONNXModels("equal_same_dims", npy, 0, 0, false, true, 2);
 703 }
 704
 705 TEST_P(Test_ONNX_layers, CompareSameDims_GT)
 706 {
 707 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2022010000)
 708     // Cannot get memory!
 709     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_CPU)
 710         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_CPU, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
 711 #elif defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2021040000)
 712     // IE exception: Function contains several inputs and outputs with one friendly name!
 713     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && (target == DNN_TARGET_OPENCL || target == DNN_TARGET_OPENCL_FP16))
 714         applyTestTag(target == DNN_TARGET_OPENCL ? CV_TEST_TAG_DNN_SKIP_IE_OPENCL : CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16,
 715             CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION
 716         );
 717     // IE exception: Function contains several inputs and outputs with one friendly name!
 718     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_MYRIAD)
 719         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
 720 #elif defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2021040000)
 721     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
 722         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
 723     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
 724         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
 725 #endif
 726
 727     testONNXModels("greater_same_dims", npy, 0, 0, false, true, 2);
 728 }
 729
 730 TEST_P(Test_ONNX_layers, CompareSameDims_LT)
 731 {
 732 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2022010000)
 733     // Cannot get memory!
 734     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_CPU)
 735         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_CPU, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
 736 #elif defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2021040000)
 737     // IE exception: Function contains several inputs and outputs with one friendly name!
 738     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && (target == DNN_TARGET_OPENCL || target == DNN_TARGET_OPENCL_FP16))
 739         applyTestTag(target == DNN_TARGET_OPENCL ? CV_TEST_TAG_DNN_SKIP_IE_OPENCL : CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16,
 740             CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION
 741         );
 742     // IE exception: Function contains several inputs and outputs with one friendly name!
 743     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_MYRIAD)
 744         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
 745 #elif defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2021040000)
 746     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
 747         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
 748     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
 749         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
 750 #endif
 751
 752     testONNXModels("less_same_dims", npy, 0, 0, false, true, 2);
 753 }
 754
 755 TEST_P(Test_ONNX_layers, Concatenation)
 756 {
 757     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
 758     {
 759         if (target == DNN_TARGET_OPENCL_FP16) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
 760         if (target == DNN_TARGET_OPENCL)      applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
 761         if (target == DNN_TARGET_MYRIAD)      applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
 762     }
 763     testONNXModels("concatenation");
 764     testONNXModels("concat_const_blobs");
 765 }
 766
 767 TEST_P(Test_ONNX_layers, Eltwise3D)
 768 {
 769 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2021040000)
 770     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 && target != DNN_TARGET_CPU)
 771         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);  // Only CPU on DLIE backend is supported
 772     else if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target != DNN_TARGET_CPU)
 773         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);  // Only CPU on DLIE backend is supported
 774 #endif
 775     testONNXModels("eltwise3d");
 776 }
 777
 778 TEST_P(Test_ONNX_layers, AveragePooling)
 779 {
 780     testONNXModels("average_pooling");
 781 }
 782
 783 TEST_P(Test_ONNX_layers, MaxPooling3D)
 784 {
 785 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2022010000)
 786     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
 787     {
 788         // accuracy
 789         if (target == DNN_TARGET_OPENCL || target == DNN_TARGET_OPENCL_FP16)
 790             applyTestTag(target == DNN_TARGET_OPENCL ? CV_TEST_TAG_DNN_SKIP_IE_OPENCL : CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16,
 791                 CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION
 792             );
 793         // IE exception: [ GENERAL_ERROR ]  AssertionFailed: !expired()
 794         if (target == DNN_TARGET_MYRIAD)
 795             applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
 796     }
 797 #elif defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2021040000)
 798     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
 799     {
 800         // accuracy
 801         if (target == DNN_TARGET_OPENCL || target == DNN_TARGET_OPENCL_FP16)
 802             applyTestTag(target == DNN_TARGET_OPENCL ? CV_TEST_TAG_DNN_SKIP_IE_OPENCL : CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16,
 803                 CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION
 804             );
 805         // IE exception: [ GENERAL_ERROR ]  AssertionFailed: !expired()
 806         if (target == DNN_TARGET_MYRIAD)
 807             applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
 808     }
 809 #endif
 810 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2021040000)
 811     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 && target != DNN_TARGET_CPU)
 812         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);  // Only CPU on DLIE backend is supported
 813     else if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target != DNN_TARGET_CPU)
 814         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);  // Only CPU on DLIE backend is supported
 815 #endif
 816     if (backend == DNN_BACKEND_OPENCV && target != DNN_TARGET_CPU)
 817         throw SkipTestException("Only CPU is supported");  // FIXIT use tags
 818
 819     if (backend == DNN_BACKEND_VKCOM)
 820         applyTestTag(CV_TEST_TAG_DNN_SKIP_VULKAN);
 821
 822     testONNXModels("max_pool3d", npy, 0, 0, false, false);
 823 }
 824
 825 TEST_P(Test_ONNX_layers, AvePooling3D)
 826 {
 827 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2021040000)
 828     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 && target != DNN_TARGET_CPU)
 829         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);  // Only CPU on DLIE backend is supported
 830     else if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target != DNN_TARGET_CPU)
 831         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);  // Only CPU on DLIE backend is supported
 832 #endif
 833     if (backend == DNN_BACKEND_OPENCV && target != DNN_TARGET_CPU)
 834         throw SkipTestException("Only CPU is supported");  // FIXIT use tags
 835
 836     if (backend == DNN_BACKEND_VKCOM)
 837         applyTestTag(CV_TEST_TAG_DNN_SKIP_VULKAN);
 838
 839     testONNXModels("ave_pool3d");
 840 }
 841
 842 TEST_P(Test_ONNX_layers, PoolConv3D)
 843 {
 844 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2021040000)
 845     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 && target != DNN_TARGET_CPU)
 846         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);  // Only CPU on DLIE backend is supported
 847     else if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target != DNN_TARGET_CPU)
 848         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);  // Only CPU on DLIE backend is supported
 849 #endif
 850     if (backend == DNN_BACKEND_OPENCV && target != DNN_TARGET_CPU)
 851         throw SkipTestException("Only CPU is supported");  // FIXIT use tags
 852
 853     if (backend == DNN_BACKEND_VKCOM)
 854         applyTestTag(CV_TEST_TAG_DNN_SKIP_VULKAN);
 855
 856     testONNXModels("pool_conv_3d");
 857 }
 858
 859 TEST_P(Test_ONNX_layers, BatchNormalization)
 860 {
 861     testONNXModels("batch_norm");
 862 }
 863
 864 TEST_P(Test_ONNX_layers, BatchNormalization3D)
 865 {
 866     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
 867     {
 868         if (target == DNN_TARGET_OPENCL_FP16) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
 869         if (target == DNN_TARGET_OPENCL)      applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
 870         if (target == DNN_TARGET_MYRIAD)      applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
 871     }
 872     testONNXModels("batch_norm_3d");
 873 }
 874
 875 TEST_P(Test_ONNX_layers, BatchNormalizationUnfused)
 876 {
 877 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2021030000)
 878     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_CPU)
 879         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_CPU, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);  // exception
 880 #endif
 881     testONNXModels("frozenBatchNorm2d");
 882 }
 883
 884 TEST_P(Test_ONNX_layers, BatchNormalizationSubgraph)
 885 {
 886 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2021030000)
 887     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_CPU)
 888         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_CPU, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);  // exception
 889 #endif
 890     testONNXModels("batch_norm_subgraph");
 891 }
 892
 893 TEST_P(Test_ONNX_layers, NormalizeFusionSubgraph)
 894 {
 895     testONNXModels("normalize_fusion");
 896 }
 897
 898 TEST_P(Test_ONNX_layers, Transpose)
 899 {
 900     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
 901     {
 902         if (target == DNN_TARGET_OPENCL_FP16) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
 903         if (target == DNN_TARGET_OPENCL)      applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
 904         if (target == DNN_TARGET_MYRIAD)      applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
 905     }
 906     testONNXModels("transpose");
 907 }
 908
 909 TEST_P(Test_ONNX_layers, Multiplication)
 910 {
 911     if (backend == DNN_BACKEND_OPENCV && target == DNN_TARGET_OPENCL_FP16)
 912         applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL_FP16);
 913     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 && target == DNN_TARGET_MYRIAD)
 914         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
 915     testONNXModels("mul");
 916 }
 917
 918 TEST_P(Test_ONNX_layers, MatMul)
 919 {
 920     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
 921         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
 922
 923     testONNXModels("matmul_2d");
 924     testONNXModels("matmul_3d");
 925     testONNXModels("matmul_4d");
 926 }
 927
 928 TEST_P(Test_ONNX_layers, MatMulAdd)
 929 {
 930 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2022010000)
 931     // accuracy
 932     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_CPU)
 933         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_CPU, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
 934 #elif defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2021010000)
 935     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
 936         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
 937 #endif
 938     if (backend == DNN_BACKEND_OPENCV && target == DNN_TARGET_OPENCL_FP16)
 939         applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL_FP16);
 940     testONNXModels("matmul_add");
 941 }
 942
 943 TEST_P(Test_ONNX_layers, Expand)
 944 {
 945     testONNXModels("expand");
 946     testONNXModels("expand_identity");
 947     testONNXModels("expand_batch");
 948     testONNXModels("expand_channels");
 949     testONNXModels("expand_neg_batch");
 950 }
 951
 952 TEST_P(Test_ONNX_layers, ExpandHW)
 953 {
 954     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
 955         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
 956     testONNXModels("expand_hw");
 957 }
 958
 959 TEST_P(Test_ONNX_layers, Constant)
 960 {
 961 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2018050000)
 962     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 && target == DNN_TARGET_MYRIAD
 963             && getInferenceEngineVPUType() == CV_DNN_INFERENCE_ENGINE_VPU_TYPE_MYRIAD_X)
 964        applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD_X, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
 965 #endif
 966     testONNXModels("constant");
 967 }
 968
 969 TEST_P(Test_ONNX_layers, Padding)
 970 {
 971 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2019010000)
 972     testONNXModels("padding", npy, 0, 0, false, false);
 973 #else
 974     testONNXModels("padding");
 975 #endif
 976 }
 977
 978 TEST_P(Test_ONNX_layers, Resize)
 979 {
 980     testONNXModels("resize_nearest");
 981     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
 982         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
 983     testONNXModels("resize_bilinear");
 984 }
 985
 986 TEST_P(Test_ONNX_layers, ResizeUnfused)
 987 {
 988     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
 989         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
 990     testONNXModels("upsample_unfused_torch1.2");
 991     testONNXModels("upsample_unfused_opset9_torch1.4");
 992     testONNXModels("resize_nearest_unfused_opset11_torch1.4");
 993     testONNXModels("resize_nearest_unfused_opset11_torch1.3");
 994     testONNXModels("resize_bilinear_unfused_opset11_torch1.4");
 995 }
 996
 997 TEST_P(Test_ONNX_layers, ResizeUnfusedTwoInputs)
 998 {
 999     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
1000         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
1001     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
1002         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
1003     testONNXModels("upsample_unfused_two_inputs_opset9_torch1.4", npy, 0, 0, false, true, 2);
1004     testONNXModels("upsample_unfused_two_inputs_opset11_torch1.4", npy, 0, 0, false, true, 2);
1005 }
1006
1007 TEST_P(Test_ONNX_layers, MultyInputs)
1008 {
1009     testONNXModels("multy_inputs", npy, 0, 0, false, true, 2);
1010 }
1011
1012 TEST_P(Test_ONNX_layers, Broadcast)
1013 {
1014     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
1015         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
1016     testONNXModels("channel_broadcast", npy, 0, 0, false, true, 2);
1017 }
1018
1019 TEST_P(Test_ONNX_layers, DynamicResize)
1020 {
1021     testONNXModels("dynamic_resize_9", npy, 0, 0, false, true, 2);
1022     testONNXModels("dynamic_resize_10", npy, 0, 0, false, true, 2);
1023     testONNXModels("dynamic_resize_11", npy, 0, 0, false, true, 2);
1024     testONNXModels("dynamic_resize_13", npy, 0, 0, false, true, 2);
1025     testONNXModels("dynamic_resize_scale_9", npy, 0, 0, false, true, 2);
1026     testONNXModels("dynamic_resize_scale_10", npy, 0, 0, false, true, 2);
1027     testONNXModels("dynamic_resize_scale_11", npy, 0, 0, false, true, 2);
1028     testONNXModels("dynamic_resize_scale_13", npy, 0, 0, false, true, 2);
1029
1030     testONNXModels("resize_size_opset11");
1031     testONNXModels("resize_size_opset13");
1032 }
1033
1034 TEST_P(Test_ONNX_layers, Resize_HumanSeg)
1035 {
1036     testONNXModels("resize_humanseg");
1037 }
1038
1039 TEST_P(Test_ONNX_layers, Div)
1040 {
1041     const String model =  _tf("models/div.onnx");
1042     Net net = readNetFromONNX(model);
1043     ASSERT_FALSE(net.empty());
1044
1045     net.setPreferableBackend(backend);
1046     net.setPreferableTarget(target);
1047
1048     // Reference output values range is -68.80928, 2.991873. So to avoid computational
1049     // difference for FP16 we'll perform reversed division (just swap inputs).
1050     Mat inp1 = blobFromNPY(_tf("data/input_div_1.npy"));
1051     Mat inp2 = blobFromNPY(_tf("data/input_div_0.npy"));
1052     Mat ref  = blobFromNPY(_tf("data/output_div.npy"));
1053     cv::divide(1.0, ref, ref);
1054     checkBackend(&inp1, &ref);
1055
1056     net.setInput(inp1, "0");
1057     net.setInput(inp2, "1");
1058     Mat out = net.forward();
1059
1060     normAssert(ref, out, "", default_l1,  default_lInf);
1061     expectNoFallbacksFromIE(net);
1062     expectNoFallbacksFromCUDA(net);
1063 }
1064
1065 TEST_P(Test_ONNX_layers, DynamicReshape)
1066 {
1067     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
1068         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
1069
1070     testONNXModels("dynamic_reshape");
1071     testONNXModels("dynamic_reshape_opset_11");
1072     testONNXModels("flatten_by_prod");
1073     testONNXModels("flatten_const");
1074 }
1075
1076 TEST_P(Test_ONNX_layers, Reshape)
1077 {
1078     testONNXModels("unsqueeze");
1079     testONNXModels("unsqueeze_opset_13");
1080 }
1081
1082 TEST_P(Test_ONNX_layers, Squeeze)
1083 {
1084     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 && target == DNN_TARGET_MYRIAD)
1085         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
1086     testONNXModels("squeeze");
1087 }
1088
1089 TEST_P(Test_ONNX_layers, ReduceL2)
1090 {
1091     testONNXModels("reduceL2");
1092     testONNXModels("reduceL2_subgraph");
1093     testONNXModels("reduceL2_subgraph_2");
1094     testONNXModels("reduceL2_subgraph2_2");
1095 }
1096
1097 TEST_P(Test_ONNX_layers, Split)
1098 {
1099     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
1100         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
1101     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
1102         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
1103     testONNXModels("split_1");
1104     testONNXModels("split_2");
1105     testONNXModels("split_3");
1106     testONNXModels("split_4");
1107     testONNXModels("split_sizes");
1108     testONNXModels("split_neg_axis");
1109 }
1110
1111 TEST_P(Test_ONNX_layers, Slice)
1112 {
1113 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2019010000)
1114     testONNXModels("slice", npy, 0, 0, false, false);
1115 #else
1116     testONNXModels("slice");
1117     testONNXModels("slice_neg_starts");
1118     testONNXModels("slice_opset_11");
1119 #endif
1120 }
1121
1122 TEST_P(Test_ONNX_layers, Slice_Steps_2DInput)
1123 {
1124     testONNXModels("slice_opset_11_steps_2d");
1125 }
1126
1127 TEST_P(Test_ONNX_layers, Slice_Steps_3DInput)
1128 {
1129 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2022010000)
1130     // Cannot get memory!
1131     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_CPU)
1132         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_CPU, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
1133     // IE exception: Cannot get memory!
1134     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && (target == DNN_TARGET_OPENCL || target == DNN_TARGET_OPENCL_FP16))
1135         applyTestTag(target == DNN_TARGET_OPENCL ? CV_TEST_TAG_DNN_SKIP_IE_OPENCL : CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16,
1136             CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION
1137         );
1138 #endif
1139
1140     testONNXModels("slice_opset_11_steps_3d");
1141 }
1142
1143 TEST_P(Test_ONNX_layers, Slice_Steps_4DInput)
1144 {
1145     testONNXModels("slice_opset_11_steps_4d");
1146 }
1147
1148 TEST_P(Test_ONNX_layers, Slice_Steps_5DInput)
1149 {
1150 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2022010000)
1151     // Cannot get memory!
1152     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_CPU)
1153         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_CPU, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
1154     // IE exception: Cannot get memory!
1155     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && (target == DNN_TARGET_OPENCL || target == DNN_TARGET_OPENCL_FP16))
1156         applyTestTag(target == DNN_TARGET_OPENCL ? CV_TEST_TAG_DNN_SKIP_IE_OPENCL : CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16,
1157             CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION
1158         );
1159     // Cannot get memory!
1160     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_MYRIAD)
1161         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
1162 #endif
1163
1164     testONNXModels("slice_opset_11_steps_5d");
1165 }
1166
1167 TEST_P(Test_ONNX_layers, Softmax)
1168 {
1169     testONNXModels("softmax");
1170     testONNXModels("log_softmax", npy, 0, 0, false, false);
1171     testONNXModels("softmax_unfused");
1172 }
1173
1174 TEST_P(Test_ONNX_layers, Split_EltwiseMax)
1175 {
1176     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
1177         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
1178     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
1179         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
1180     testONNXModels("split_max");
1181 }
1182
1183 TEST_P(Test_ONNX_layers, LSTM_Activations)
1184 {
1185 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2022010000)
1186     // Cannot get memory!
1187     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_CPU)
1188         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_CPU, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
1189     // IE exception: Node Block1326/lstm/reshape_0/permute was not assigned on any pointed device
1190     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && (target == DNN_TARGET_OPENCL || target == DNN_TARGET_OPENCL_FP16))
1191         applyTestTag(target == DNN_TARGET_OPENCL ? CV_TEST_TAG_DNN_SKIP_IE_OPENCL : CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16,
1192             CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION
1193         );
1194 #elif defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2021040000)
1195     // IE Exception: Ngraph operation Reshape with name Block1237_Output_0_before_reshape has dynamic output shape on 0 port, but CPU plug-in supports only static shape
1196     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && (target == DNN_TARGET_OPENCL || target == DNN_TARGET_OPENCL_FP16))
1197         applyTestTag(target == DNN_TARGET_OPENCL ? CV_TEST_TAG_DNN_SKIP_IE_OPENCL : CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16,
1198             CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION
1199         );
1200 #endif
1201
1202     testONNXModels("lstm_cntk_tanh", pb, 0, 0, false, false);
1203 }
1204
1205 // disabled due to poor handling of 1-d mats
1206 TEST_P(Test_ONNX_layers, DISABLED_LSTM)
1207 {
1208     testONNXModels("lstm", npy, 0, 0, false, false);
1209 }
1210
1211 // disabled due to poor handling of 1-d mats
1212 TEST_P(Test_ONNX_layers, DISABLED_LSTM_bidirectional)
1213 {
1214     testONNXModels("lstm_bidirectional", npy, 0, 0, false, false);
1215 }
1216
1217 TEST_P(Test_ONNX_layers, LSTM_hidden)
1218 {
1219     testONNXModels("hidden_lstm", npy, 0, 0, false, false);
1220 }
1221
1222 TEST_P(Test_ONNX_layers, LSTM_hidden_bidirectional)
1223 {
1224 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2022010000)
1225     // Cannot get memory!
1226     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_CPU)
1227         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_CPU, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
1228     // IE exception: Node Transpose_45 was not assigned on any pointed device.
1229     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && (target == DNN_TARGET_OPENCL || target == DNN_TARGET_OPENCL_FP16))
1230         applyTestTag(target == DNN_TARGET_OPENCL ? CV_TEST_TAG_DNN_SKIP_IE_OPENCL : CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16,
1231             CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION
1232         );
1233 #endif
1234
1235     testONNXModels("hidden_lstm_bi", npy, 0, 0, false, false);
1236 }
1237
1238 TEST_P(Test_ONNX_layers, GRU)
1239 {
1240 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2022010000)
1241     // Cannot get memory!
1242     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_CPU)
1243         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_CPU, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
1244     // IE exception: Node GRU_22 was not assigned on any pointed device
1245     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && (target == DNN_TARGET_OPENCL || target == DNN_TARGET_OPENCL_FP16))
1246         applyTestTag(target == DNN_TARGET_OPENCL ? CV_TEST_TAG_DNN_SKIP_IE_OPENCL : CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16,
1247             CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION
1248         );
1249 #endif
1250     testONNXModels("gru", npy, 0, 0, false, false);
1251 }
1252
1253 TEST_P(Test_ONNX_layers, GRU_bidirectional)
1254 {
1255     testONNXModels("gru_bi", npy, 0, 0, false, false);
1256 }
1257
1258 TEST_P(Test_ONNX_layers, LSTM_cell_forward)
1259 {
1260 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2022010000)
1261     // accuracy!
1262     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_CPU)
1263         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_CPU, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
1264 #elif defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2021040000)
1265     // Ngraph operation Reshape with name LSTM_16/lstm_y/reshape has dynamic output shape on 0 port, but CPU plug-in supports only static shape
1266     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_OPENCL)
1267         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
1268     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_OPENCL_FP16)
1269         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
1270 #endif
1271     testONNXModels("lstm_cell_forward", npy, 0, 0, false, false);
1272 }
1273 TEST_P(Test_ONNX_layers, LSTM_cell_bidirectional)
1274 {
1275 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2022010000)
1276     // Cannot get memory!
1277     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_CPU)
1278         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_CPU, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
1279 #elif defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2021040000)
1280     // Ngraph operation Reshape with name LSTM_16/lstm_y/reshape has dynamic output shape on 0 port, but CPU plug-in supports only static shape
1281     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_OPENCL)
1282         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
1283     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_OPENCL_FP16)
1284         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
1285 #endif
1286     testONNXModels("lstm_cell_bidirectional", npy, 0, 0, false, false);
1287 }
1288 TEST_P(Test_ONNX_layers, LSTM_cell_with_peepholes)
1289 {
1290     testONNXModels("lstm_cell_with_peepholes", npy, 0, 0, false, false);
1291 }
1292
1293 TEST_P(Test_ONNX_layers, Pad2d_Unfused)
1294 {
1295     testONNXModels("ReflectionPad2d");
1296     testONNXModels("ZeroPad2d");
1297 }
1298
1299 TEST_P(Test_ONNX_layers, LinearWithConstant)
1300 {
1301     if (backend == DNN_BACKEND_OPENCV && target == DNN_TARGET_OPENCL_FP16)
1302         applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL_FP16);
1303 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2020040000)
1304     applyTestTag(CV_TEST_TAG_DNN_SKIP_IE);
1305 #endif
1306     if (backend == DNN_BACKEND_CUDA)
1307         applyTestTag(CV_TEST_TAG_DNN_SKIP_CUDA);
1308     testONNXModels("lin_with_constant");
1309 }
1310
1311 TEST_P(Test_ONNX_layers, MatmulWithTwoInputs)
1312 {
1313     if (backend == DNN_BACKEND_OPENCV && target == DNN_TARGET_OPENCL_FP16)
1314         applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL_FP16);
1315 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2020040000)
1316     applyTestTag(CV_TEST_TAG_DNN_SKIP_IE);
1317 #endif
1318     testONNXModels("matmul_with_two_inputs");
1319 }
1320
1321 TEST_P(Test_ONNX_layers, ResizeOpset11_Torch1_6)
1322 {
1323     testONNXModels("resize_opset11_torch1.6");
1324 }
1325
1326 TEST_P(Test_ONNX_layers, Mish)
1327 {
1328     testONNXModels("mish");
1329 }
1330
1331 TEST_P(Test_ONNX_layers, CalculatePads)
1332 {
1333     testONNXModels("calc_pads");
1334 }
1335
1336 TEST_P(Test_ONNX_layers, Conv1d)
1337 {
1338     testONNXModels("conv1d");
1339 }
1340
1341 TEST_P(Test_ONNX_layers, Conv1d_bias)
1342 {
1343     testONNXModels("conv1d_bias");
1344 }
1345
1346 TEST_P(Test_ONNX_layers, Conv1d_variable_weight)
1347 {
1348     if (backend == DNN_BACKEND_CUDA)
1349         applyTestTag(CV_TEST_TAG_DNN_SKIP_CUDA); // not supported
1350     if (backend == DNN_BACKEND_VKCOM)
1351         applyTestTag(CV_TEST_TAG_DNN_SKIP_VULKAN); // not supported
1352     String basename = "conv1d_variable_w";
1353     Net net = readNetFromONNX(_tf("models/" + basename + ".onnx"));
1354     ASSERT_FALSE(net.empty());
1355
1356     net.setPreferableBackend(backend);
1357     net.setPreferableTarget(target);
1358
1359     Mat input = blobFromNPY(_tf("data/input_" + basename + "_0.npy"));
1360     Mat weights = blobFromNPY(_tf("data/input_" + basename + "_1.npy"));
1361     Mat ref = blobFromNPY(_tf("data/output_" + basename + ".npy"));
1362
1363     net.setInput(input, "0");
1364     net.setInput(weights, "1");
1365
1366     Mat out = net.forward();
1367     normAssert(ref, out, "", default_l1, default_lInf);
1368 }
1369
1370 TEST_P(Test_ONNX_layers, Conv1d_variable_weight_bias)
1371 {
1372     if (backend == DNN_BACKEND_CUDA)
1373         applyTestTag(CV_TEST_TAG_DNN_SKIP_CUDA); // not supported
1374     if (backend == DNN_BACKEND_VKCOM)
1375         applyTestTag(CV_TEST_TAG_DNN_SKIP_VULKAN); // not supported
1376     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
1377     {
1378         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
1379         if (target == DNN_TARGET_CPU && getInferenceEngineCPUType() == CV_DNN_INFERENCE_ENGINE_CPU_TYPE_ARM_COMPUTE)
1380             applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_ARM_CPU, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
1381     }
1382     String basename = "conv1d_variable_wb";
1383     Net net = readNetFromONNX(_tf("models/" + basename + ".onnx"));
1384     ASSERT_FALSE(net.empty());
1385
1386     net.setPreferableBackend(backend);
1387     net.setPreferableTarget(target);
1388
1389     Mat input = blobFromNPY(_tf("data/input_" + basename + "_0.npy"));
1390     Mat weights = blobFromNPY(_tf("data/input_" + basename + "_1.npy"));
1391     Mat bias = blobFromNPY(_tf("data/input_" + basename + "_2.npy"));
1392     Mat ref = blobFromNPY(_tf("data/output_" + basename + ".npy"));
1393
1394     net.setInput(input, "0");
1395     net.setInput(weights, "1");
1396     net.setInput(bias, "bias");
1397
1398     Mat out = net.forward();
1399     normAssert(ref, out, "", default_l1, default_lInf);
1400 }
1401
1402 TEST_P(Test_ONNX_layers, GatherMultiOutput)
1403 {
1404 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2021040000)
1405     // IE Exception: Ngraph operation Reshape with name 6 has dynamic output shape on 0 port, but CPU plug-in supports only static shape
1406     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && (target == DNN_TARGET_OPENCL || target == DNN_TARGET_OPENCL_FP16))
1407         applyTestTag(target == DNN_TARGET_OPENCL ? CV_TEST_TAG_DNN_SKIP_IE_OPENCL : CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16,
1408             CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION
1409         );
1410 #endif
1411 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2021030000)
1412     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_OPENCL)
1413         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);  // exception
1414     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_OPENCL_FP16)
1415         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);  // exception
1416 #endif
1417
1418 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LE(2021030000)
1419     if (target == DNN_TARGET_MYRIAD)
1420         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE);
1421 #endif
1422
1423     testONNXModels("gather_multi_output");
1424 }
1425
1426 TEST_P(Test_ONNX_layers, DynamicAxes_squeeze_and_conv)
1427 {
1428 #if defined(INF_ENGINE_RELEASE)
1429     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
1430     {
1431         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
1432     }
1433 #if INF_ENGINE_VER_MAJOR_LT(2021000000)
1434     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
1435     {
1436         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
1437     }
1438 #endif
1439 #endif
1440     testONNXModels("squeeze_and_conv_dynamic_axes");
1441 }
1442
1443 TEST_P(Test_ONNX_layers, DynamicAxes_unsqueeze_and_conv)
1444 {
1445 #if defined(INF_ENGINE_RELEASE)
1446     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
1447     {
1448         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
1449     }
1450 #if INF_ENGINE_VER_MAJOR_LT(2021000000)
1451     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
1452     {
1453         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
1454     }
1455 #endif
1456 #endif
1457     testONNXModels("unsqueeze_and_conv_dynamic_axes");
1458 }
1459
1460 TEST_P(Test_ONNX_layers, DynamicAxes_gather)
1461 {
1462 #if defined(INF_ENGINE_RELEASE)
1463     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
1464     {
1465         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
1466     }
1467 #if INF_ENGINE_VER_MAJOR_LT(2021000000)
1468     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
1469     {
1470         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
1471     }
1472 #endif
1473 #endif
1474     testONNXModels("gather_dynamic_axes");
1475 }
1476
1477 TEST_P(Test_ONNX_layers, DynamicAxes_gather_scalar)
1478 {
1479 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2022010000)
1480     // accuracy
1481     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && (target == DNN_TARGET_OPENCL || target == DNN_TARGET_OPENCL_FP16))
1482         applyTestTag(target == DNN_TARGET_OPENCL ? CV_TEST_TAG_DNN_SKIP_IE_OPENCL : CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16,
1483             CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION
1484         );
1485 #elif defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2021040000)
1486     // accuracy
1487     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && (target == DNN_TARGET_OPENCL || target == DNN_TARGET_OPENCL_FP16))
1488         applyTestTag(target == DNN_TARGET_OPENCL ? CV_TEST_TAG_DNN_SKIP_IE_OPENCL : CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16,
1489             CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION
1490         );
1491 #elif defined(INF_ENGINE_RELEASE)
1492     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
1493     {
1494         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
1495     }
1496 #if INF_ENGINE_VER_MAJOR_LT(2021000000)
1497     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
1498     {
1499         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
1500     }
1501 #endif
1502 #endif
1503     testONNXModels("gather_scalar_dynamic_axes");
1504 }
1505
1506 TEST_P(Test_ONNX_layers, DynamicAxes_slice)
1507 {
1508 #if defined(INF_ENGINE_RELEASE)
1509     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
1510     {
1511         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
1512     }
1513 #if INF_ENGINE_VER_MAJOR_LT(2021000000)
1514     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
1515     {
1516         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
1517     }
1518 #endif
1519 #endif
1520     testONNXModels("slice_dynamic_axes");
1521 }
1522
1523 TEST_P(Test_ONNX_layers, DynamicAxes_slice_opset_11)
1524 {
1525 #if defined(INF_ENGINE_RELEASE)
1526     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
1527     {
1528         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
1529     }
1530 #if INF_ENGINE_VER_MAJOR_LT(2021000000)
1531     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
1532     {
1533         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
1534     }
1535 #endif
1536 #endif
1537     testONNXModels("slice_opset_11_dynamic_axes");
1538 }
1539
1540 TEST_P(Test_ONNX_layers, DynamicAxes_resize_opset11_torch16)
1541 {
1542 #if defined(INF_ENGINE_RELEASE)
1543     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
1544     {
1545         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
1546     }
1547 #if INF_ENGINE_VER_MAJOR_LT(2021000000)
1548     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
1549     {
1550         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
1551     }
1552 #endif
1553 #endif
1554     testONNXModels("resize_opset11_torch1.6_dynamic_axes");
1555 }
1556
1557 TEST_P(Test_ONNX_layers, DynamicAxes_average_pooling)
1558 {
1559 #if defined(INF_ENGINE_RELEASE)
1560     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
1561     {
1562         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
1563     }
1564 #if INF_ENGINE_VER_MAJOR_LT(2021000000)
1565     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
1566     {
1567         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
1568     }
1569 #endif
1570 #endif
1571     testONNXModels("average_pooling_dynamic_axes");
1572 }
1573
1574 TEST_P(Test_ONNX_layers, DynamicAxes_maxpooling_sigmoid)
1575 {
1576 #if defined(INF_ENGINE_RELEASE)
1577     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
1578     {
1579         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
1580     }
1581 #if INF_ENGINE_VER_MAJOR_LT(2021000000)
1582     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
1583     {
1584         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
1585     }
1586 #endif
1587 #endif
1588     testONNXModels("maxpooling_sigmoid_dynamic_axes");
1589 }
1590
1591 TEST_P(Test_ONNX_layers, DynamicAxes_dynamic_batch)
1592 {
1593 #if defined(INF_ENGINE_RELEASE)
1594     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
1595     {
1596         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
1597     }
1598 #if INF_ENGINE_VER_MAJOR_LT(2021000000)
1599     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
1600     {
1601         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
1602     }
1603 #endif
1604 #endif
1605     testONNXModels("dynamic_batch");
1606 }
1607
1608
1609 TEST_P(Test_ONNX_layers, MaxPool1d)
1610 {
1611 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2021040000)
1612     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
1613     {
1614         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
1615     }
1616     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
1617     {
1618         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
1619     }
1620 #endif
1621 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_GE(2021040000)
1622     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_MYRIAD)
1623     {
1624         // 2021.4: [ GENERAL_ERROR ]  AssertionFailed: !expired()
1625         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
1626     }
1627 #endif
1628     testONNXModels("maxpooling_1d");
1629 }
1630
1631 TEST_P(Test_ONNX_layers, MaxPoolSigmoid1d)
1632 {
1633 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2022010000)
1634     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_CPU)
1635         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_CPU, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
1636 #elif defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2021040000)
1637     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
1638     {
1639         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
1640     }
1641     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
1642     {
1643         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
1644     }
1645 #endif
1646     testONNXModels("maxpooling_sigmoid_1d");
1647 }
1648
1649 TEST_P(Test_ONNX_layers, MaxPool1d_Twise)
1650 {
1651 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2022010000)
1652     // Cannot get memory!
1653     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_CPU)
1654         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_CPU, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
1655     // Cannot get memory!
1656     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && (target == DNN_TARGET_OPENCL || target == DNN_TARGET_OPENCL_FP16))
1657         applyTestTag(target == DNN_TARGET_OPENCL ? CV_TEST_TAG_DNN_SKIP_IE_OPENCL : CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16,
1658             CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION
1659         );
1660 #elif defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2021040000)
1661     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
1662     {
1663         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
1664     }
1665     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
1666     {
1667         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
1668     }
1669 #endif
1670     testONNXModels("two_maxpooling_1d");
1671 }
1672
1673 TEST_P(Test_ONNX_layers, AvePool1d)
1674 {
1675 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2022010000)
1676     // Cannot get memory!
1677     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_MYRIAD)
1678         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
1679 #elif defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2021040000)
1680     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
1681     {
1682         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
1683     }
1684     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
1685     {
1686         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
1687     }
1688 #endif
1689     testONNXModels("average_pooling_1d");
1690 }
1691
1692 TEST_P(Test_ONNX_layers, PoolConv1d)
1693 {
1694 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2022010000)
1695     // Cannot get memory!
1696     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_CPU)
1697         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_CPU, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
1698     // Cannot get memory!
1699     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_MYRIAD)
1700         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
1701     // Cannot get memory!
1702     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && (target == DNN_TARGET_OPENCL || target == DNN_TARGET_OPENCL_FP16))
1703         applyTestTag(target == DNN_TARGET_OPENCL ? CV_TEST_TAG_DNN_SKIP_IE_OPENCL : CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16,
1704             CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION
1705         );
1706 #elif defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2021040000)
1707     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
1708     {
1709         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
1710     }
1711     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
1712     {
1713         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
1714     }
1715 #endif
1716     testONNXModels("pool_conv_1d");
1717 }
1718
1719 TEST_P(Test_ONNX_layers, ConvResizePool1d)
1720 {
1721 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2021040000)
1722     // IE Exception: Ngraph operation Reshape with name 15 has dynamic output shape on 0 port, but CPU plug-in supports only static shape
1723     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && (target == DNN_TARGET_OPENCL || target == DNN_TARGET_OPENCL_FP16))
1724         applyTestTag(target == DNN_TARGET_OPENCL ? CV_TEST_TAG_DNN_SKIP_IE_OPENCL : CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16,
1725             CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION
1726         );
1727 #endif
1728 #if defined(INF_ENGINE_RELEASE)
1729     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
1730     {
1731         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
1732     }
1733     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
1734     {
1735         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
1736 #if INF_ENGINE_VER_MAJOR_EQ(2021030000)
1737         if (target == DNN_TARGET_OPENCL) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);  // exception
1738         if (target == DNN_TARGET_OPENCL_FP16) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);  // exception
1739 #endif
1740     }
1741 #endif
1742     testONNXModels("conv_resize_pool_1d");
1743 }
1744
1745 TEST_P(Test_ONNX_layers, SubFromConst)
1746 {
1747     testONNXModels("sub_from_const1");
1748     testONNXModels("sub_from_const_eltwise");
1749     testONNXModels("sub_from_const_broadcast");
1750 }
1751
1752 TEST_P(Test_ONNX_layers, DivConst)
1753 {
1754     testONNXModels("div_const");
1755 }
1756
1757 TEST_P(Test_ONNX_layers, Gemm)
1758 {
1759     testONNXModels("gemm_no_transB");
1760     testONNXModels("gemm_transB_0");
1761 }
1762
1763 TEST_P(Test_ONNX_layers, Quantized_Convolution)
1764 {
1765     testONNXModels("quantized_conv_uint8_weights", npy, 0.004, 0.02);
1766     testONNXModels("quantized_conv_int8_weights", npy, 0.03, 0.5);
1767     testONNXModels("quantized_conv_per_channel_weights", npy, 0.06, 0.4);
1768
1769     testONNXModels("quantized_conv_asymmetric_pads_int8_weights");
1770 }
1771
1772 TEST_P(Test_ONNX_layers, Quantized_MatMul)
1773 {
1774     testONNXModels("quantized_matmul_uint8_weights", npy, 0.005, 0.007);
1775     testONNXModels("quantized_matmul_int8_weights", npy, 0.06, 0.2);
1776     testONNXModels("quantized_matmul_per_channel_weights", npy, 0.06, 0.22);
1777 }
1778
1779 TEST_P(Test_ONNX_layers, Quantized_MatMul_Variable_Weights)
1780 {
1781     // Unsupported
1782     EXPECT_THROW(
1783     {
1784         testONNXModels("quantized_matmul_variable_inputs");
1785     }, cv::Exception);
1786 }
1787
1788 TEST_P(Test_ONNX_layers, Quantized_Eltwise)
1789 {
1790     testONNXModels("quantized_eltwise");
1791 }
1792
1793 TEST_P(Test_ONNX_layers, Quantized_Eltwise_Scalar)
1794 {
1795     testONNXModels("quantized_eltwise_scalar");
1796 }
1797
1798 TEST_P(Test_ONNX_layers, Quantized_Eltwise_Broadcast)
1799 {
1800     testONNXModels("quantized_eltwise_broadcast");
1801 }
1802
1803 TEST_P(Test_ONNX_layers, Quantized_LeakyReLU)
1804 {
1805     testONNXModels("quantized_leaky_relu");
1806 }
1807
1808 TEST_P(Test_ONNX_layers, Quantized_Sigmoid)
1809 {
1810     testONNXModels("quantized_sigmoid");
1811 }
1812
1813 TEST_P(Test_ONNX_layers, Quantized_MaxPool)
1814 {
1815     testONNXModels("quantized_maxpool");
1816 }
1817
1818 TEST_P(Test_ONNX_layers, Quantized_AvgPool)
1819 {
1820     testONNXModels("quantized_avgpool");
1821 }
1822
1823 TEST_P(Test_ONNX_layers, Quantized_Split)
1824 {
1825     testONNXModels("quantized_split");
1826 }
1827
1828 TEST_P(Test_ONNX_layers, Quantized_Pad)
1829 {
1830     testONNXModels("quantized_padding");
1831 }
1832
1833 TEST_P(Test_ONNX_layers, Quantized_Reshape)
1834 {
1835     testONNXModels("quantized_reshape");
1836 }
1837
1838 TEST_P(Test_ONNX_layers, Quantized_Transpose)
1839 {
1840     testONNXModels("quantized_transpose");
1841 }
1842
1843 TEST_P(Test_ONNX_layers, Quantized_Squeeze)
1844 {
1845     testONNXModels("quantized_squeeze");
1846 }
1847
1848 TEST_P(Test_ONNX_layers, Quantized_Unsqueeze)
1849 {
1850     testONNXModels("quantized_unsqueeze");
1851 }
1852
1853 TEST_P(Test_ONNX_layers, Quantized_Resize)
1854 {
1855     testONNXModels("quantized_resize_nearest");
1856     testONNXModels("quantized_resize_bilinear", npy, 2e-4, 0.003);
1857     testONNXModels("quantized_resize_bilinear_align", npy, 3e-4, 0.003);
1858 }
1859
1860 TEST_P(Test_ONNX_layers, Quantized_Concat)
1861 {
1862     testONNXModels("quantized_concat");
1863     testONNXModels("quantized_concat_const_blob");
1864 }
1865
1866 TEST_P(Test_ONNX_layers, Quantized_Constant)
1867 {
1868     testONNXModels("quantized_constant", npy, 0.002, 0.008);
1869 }
1870
1871 TEST_P(Test_ONNX_layers, OutputRegistration)
1872 {
1873     testONNXModels("output_registration", npy, 0, 0, false, true, 2);
1874 }
1875
1876 INSTANTIATE_TEST_CASE_P(/*nothing*/, Test_ONNX_layers, dnnBackendsAndTargets());
1877
1878 class Test_ONNX_nets : public Test_ONNX_layers
1879 {
1880 public:
1881     Test_ONNX_nets() { required = false; }
1882 };
1883
1884 TEST_P(Test_ONNX_nets, Alexnet)
1885 {
1886 #if defined(OPENCV_32BIT_CONFIGURATION) && (defined(HAVE_OPENCL) || defined(_WIN32))
1887     applyTestTag(CV_TEST_TAG_MEMORY_2GB);
1888 #else
1889     applyTestTag(target == DNN_TARGET_CPU ? CV_TEST_TAG_MEMORY_512MB : CV_TEST_TAG_MEMORY_1GB);
1890 #endif
1891
1892     const String model =  _tf("models/alexnet.onnx", false);
1893
1894     Net net = readNetFromONNX(model);
1895     ASSERT_FALSE(net.empty());
1896
1897     net.setPreferableBackend(backend);
1898     net.setPreferableTarget(target);
1899
1900     Mat inp = imread(_tf("../grace_hopper_227.png"));
1901     Mat ref = blobFromNPY(_tf("../caffe_alexnet_prob.npy"));
1902     checkBackend(&inp, &ref);
1903
1904     net.setInput(blobFromImage(inp, 1.0f, Size(227, 227), Scalar(), false));
1905     ASSERT_FALSE(net.empty());
1906     Mat out = net.forward();
1907
1908     normAssert(out, ref, "", default_l1,  default_lInf);
1909     expectNoFallbacksFromIE(net);
1910 }
1911
1912 TEST_P(Test_ONNX_nets, Squeezenet)
1913 {
1914     testONNXModels("squeezenet", pb);
1915 }
1916
1917 TEST_P(Test_ONNX_nets, Googlenet)
1918 {
1919 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2022010000)
1920     // accuracy
1921     if (target == DNN_TARGET_MYRIAD)
1922         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
1923 #elif defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2021040000)
1924     // accuracy
1925     if (target == DNN_TARGET_MYRIAD)
1926         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
1927 #elif defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2021040000)
1928     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
1929         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
1930
1931     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
1932         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
1933 #endif
1934
1935     const String model = _tf("models/googlenet.onnx", false);
1936
1937     Net net = readNetFromONNX(model);
1938     ASSERT_FALSE(net.empty());
1939
1940     net.setPreferableBackend(backend);
1941     net.setPreferableTarget(target);
1942
1943     std::vector<Mat> images;
1944     images.push_back( imread(_tf("../googlenet_0.png")) );
1945     images.push_back( imread(_tf("../googlenet_1.png")) );
1946     Mat inp = blobFromImages(images, 1.0f, Size(), Scalar(), false);
1947     Mat ref = blobFromNPY(_tf("../googlenet_prob.npy"));
1948     checkBackend(&inp, &ref);
1949
1950     net.setInput(inp);
1951     ASSERT_FALSE(net.empty());
1952     Mat out = net.forward();
1953
1954     normAssert(ref, out, "", default_l1,  default_lInf);
1955     expectNoFallbacksFromIE(net);
1956 }
1957
1958 TEST_P(Test_ONNX_nets, CaffeNet)
1959 {
1960 #if defined(OPENCV_32BIT_CONFIGURATION) && (defined(HAVE_OPENCL) || defined(_WIN32))
1961     applyTestTag(CV_TEST_TAG_MEMORY_2GB);
1962 #else
1963     applyTestTag(target == DNN_TARGET_CPU ? CV_TEST_TAG_MEMORY_512MB : CV_TEST_TAG_MEMORY_1GB);
1964 #endif
1965
1966 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2019030000)
1967     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 && target == DNN_TARGET_MYRIAD
1968         && getInferenceEngineVPUType() == CV_DNN_INFERENCE_ENGINE_VPU_TYPE_MYRIAD_X)
1969         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD_X, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
1970 #endif
1971     testONNXModels("caffenet", pb);
1972 }
1973
1974 TEST_P(Test_ONNX_nets, RCNN_ILSVRC13)
1975 {
1976 #if defined(OPENCV_32BIT_CONFIGURATION) && (defined(HAVE_OPENCL) || defined(_WIN32))
1977     applyTestTag(CV_TEST_TAG_MEMORY_2GB);
1978 #else
1979     applyTestTag(target == DNN_TARGET_CPU ? CV_TEST_TAG_MEMORY_512MB : CV_TEST_TAG_MEMORY_1GB);
1980 #endif
1981
1982 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2019030000)
1983     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 && target == DNN_TARGET_MYRIAD
1984         && getInferenceEngineVPUType() == CV_DNN_INFERENCE_ENGINE_VPU_TYPE_MYRIAD_X)
1985         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD_X, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
1986 #endif
1987     // Reference output values are in range [-4.992, -1.161]
1988     testONNXModels("rcnn_ilsvrc13", pb, 0.0046);
1989 }
1990
1991 TEST_P(Test_ONNX_nets, VGG16_bn)
1992 {
1993     applyTestTag(CV_TEST_TAG_MEMORY_6GB);  // > 2.3Gb
1994
1995     // output range: [-16; 27], after Softmax [0; 0.67]
1996     const double lInf = (target == DNN_TARGET_MYRIAD) ? 0.038 : default_lInf;
1997     testONNXModels("vgg16-bn", pb, default_l1, lInf, true);
1998 }
1999
2000 TEST_P(Test_ONNX_nets, ZFNet)
2001 {
2002     applyTestTag(CV_TEST_TAG_MEMORY_2GB);
2003     testONNXModels("zfnet512", pb);
2004 }
2005
2006 TEST_P(Test_ONNX_nets, ResNet18v1)
2007 {
2008     applyTestTag(CV_TEST_TAG_MEMORY_512MB);
2009
2010     // output range: [-16; 22], after Softmax [0, 0.51]
2011     testONNXModels("resnet18v1", pb, default_l1, default_lInf, true, target != DNN_TARGET_MYRIAD);
2012 }
2013
2014 TEST_P(Test_ONNX_nets, ResNet50v1)
2015 {
2016     applyTestTag(CV_TEST_TAG_MEMORY_512MB);
2017
2018     // output range: [-67; 75], after Softmax [0, 0.98]
2019     testONNXModels("resnet50v1", pb, default_l1, default_lInf, true, target != DNN_TARGET_MYRIAD);
2020 }
2021
2022 TEST_P(Test_ONNX_nets, ResNet50_Int8)
2023 {
2024     testONNXModels("resnet50_int8", pb, default_l1, default_lInf, true);
2025 }
2026
2027 TEST_P(Test_ONNX_nets, ResNet101_DUC_HDC)
2028 {
2029     applyTestTag(CV_TEST_TAG_VERYLONG);
2030
2031 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_GE(2019010000)
2032     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
2033         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
2034 #endif
2035 #if defined(INF_ENGINE_RELEASE)
2036     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 && target == DNN_TARGET_MYRIAD)
2037         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
2038 #endif
2039     if (target == DNN_TARGET_OPENCL_FP16 || target == DNN_TARGET_OPENCL)
2040     {
2041         if (backend == DNN_BACKEND_OPENCV)
2042             applyTestTag(target == DNN_TARGET_OPENCL ? CV_TEST_TAG_DNN_SKIP_OPENCL : CV_TEST_TAG_DNN_SKIP_OPENCL_FP16);
2043         throw SkipTestException("Test is disabled for OpenCL targets");
2044     }
2045     testONNXModels("resnet101_duc_hdc", pb);
2046 }
2047
2048 TEST_P(Test_ONNX_nets, TinyYolov2)
2049 {
2050     applyTestTag(CV_TEST_TAG_MEMORY_512MB);
2051
2052     if (cvtest::skipUnstableTests)
2053         throw SkipTestException("Skip unstable test");
2054 #if defined(INF_ENGINE_RELEASE)
2055     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019
2056             && (target == DNN_TARGET_OPENCL || target == DNN_TARGET_OPENCL_FP16)
2057     )
2058         applyTestTag(target == DNN_TARGET_OPENCL ? CV_TEST_TAG_DNN_SKIP_IE_OPENCL : CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
2059
2060     if (target == DNN_TARGET_MYRIAD && getInferenceEngineVPUType() == CV_DNN_INFERENCE_ENGINE_VPU_TYPE_MYRIAD_X
2061     )
2062         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD_X,
2063                      backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 ?
2064                      CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER :
2065                      CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
2066 #endif
2067
2068     // output range: [-11; 8]
2069     double l1 =  default_l1, lInf = default_lInf;
2070     if (target == DNN_TARGET_OPENCL_FP16 || target == DNN_TARGET_MYRIAD)
2071     {
2072         l1 = 0.02;
2073         lInf = 0.2;
2074     }
2075     else if (target == DNN_TARGET_CUDA_FP16)
2076     {
2077         l1 = 0.018;
2078         lInf = 0.16;
2079     }
2080 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2020040000)
2081     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_OPENCL_FP16)
2082     {
2083         l1 = 0.018f; lInf = 0.16f;
2084     }
2085 #endif
2086
2087     testONNXModels("tiny_yolo2", pb, l1, lInf);
2088 }
2089
2090 TEST_P(Test_ONNX_nets, CNN_MNIST)
2091 {
2092     // output range: [-1952; 6574], after Softmax [0; 1]
2093     testONNXModels("cnn_mnist", pb, default_l1, default_lInf, true);
2094 }
2095
2096 TEST_P(Test_ONNX_nets, MobileNet_v2)
2097 {
2098     // output range: [-166; 317], after Softmax [0; 1]
2099     testONNXModels("mobilenetv2", pb, default_l1, default_lInf, true);
2100 }
2101
2102 TEST_P(Test_ONNX_nets, LResNet100E_IR)
2103 {
2104     applyTestTag(
2105 #if defined(OPENCV_32BIT_CONFIGURATION) && defined(HAVE_OPENCL)
2106         CV_TEST_TAG_MEMORY_2GB,
2107 #else
2108         (target == DNN_TARGET_CPU ? CV_TEST_TAG_MEMORY_512MB : CV_TEST_TAG_MEMORY_1GB),
2109 #endif
2110         CV_TEST_TAG_DEBUG_LONG
2111     );
2112     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
2113     {
2114         if (target == DNN_TARGET_OPENCL_FP16) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
2115         if (target == DNN_TARGET_OPENCL)      applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
2116         if (target == DNN_TARGET_MYRIAD)      applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
2117     }
2118     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
2119     {
2120         if (target == DNN_TARGET_OPENCL_FP16) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
2121         if (target == DNN_TARGET_OPENCL)      applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
2122         if (target == DNN_TARGET_MYRIAD)      applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
2123     }
2124
2125     double l1 = default_l1, lInf = default_lInf;
2126     // output range: [-3; 3]
2127     if (backend == DNN_BACKEND_OPENCV && target == DNN_TARGET_OPENCL_FP16)
2128     {
2129         l1 = 0.009;
2130         lInf = 0.035;
2131     }
2132     else if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 && target == DNN_TARGET_CPU)
2133     {
2134         l1 = 4.6e-5;
2135         lInf = 1.9e-4;
2136     }
2137     else if (target == DNN_TARGET_CUDA_FP16)
2138     {
2139         l1 = 0.008;
2140         lInf = 0.04;
2141     }
2142     testONNXModels("LResNet100E_IR", pb, l1, lInf);
2143 }
2144
2145 TEST_P(Test_ONNX_nets, Emotion_ferplus)
2146 {
2147 #if defined(INF_ENGINE_RELEASE)
2148     if (target == DNN_TARGET_MYRIAD && getInferenceEngineVPUType() == CV_DNN_INFERENCE_ENGINE_VPU_TYPE_MYRIAD_X)
2149         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD_X,
2150                      backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 ?
2151                      CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER :
2152                      CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
2153 #endif
2154
2155     double l1 = default_l1;
2156     double lInf = default_lInf;
2157
2158     // Output values are in range [-2.011, 2.111]
2159     if ((backend == DNN_BACKEND_OPENCV && target == DNN_TARGET_OPENCL_FP16) || (target == DNN_TARGET_CUDA_FP16))
2160         l1 = 0.007;
2161     else if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 && target == DNN_TARGET_OPENCL_FP16)
2162     {
2163         l1 = 0.021;
2164         lInf = 0.034;
2165     }
2166     else if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 && (target == DNN_TARGET_CPU || target == DNN_TARGET_OPENCL)) {
2167         l1 = 2.4e-4;
2168         lInf = 6e-4;
2169     }
2170 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_GE(2020040000)
2171     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_OPENCL_FP16)
2172     {
2173         l1 = 0.013f; lInf = 0.035f;
2174     }
2175 #endif
2176
2177     testONNXModels("emotion_ferplus", pb, l1, lInf);
2178 }
2179
2180 TEST_P(Test_ONNX_nets, Inception_v2)
2181 {
2182     testONNXModels("inception_v2", pb, default_l1, default_lInf, true);
2183 }
2184
2185 TEST_P(Test_ONNX_nets, DenseNet121)
2186 {
2187     applyTestTag(CV_TEST_TAG_MEMORY_512MB);
2188
2189     // output range: [-87; 138], after Softmax [0; 1]
2190     testONNXModels("densenet121", pb, default_l1, default_lInf, true, target != DNN_TARGET_MYRIAD);
2191 }
2192
2193 TEST_P(Test_ONNX_nets, Inception_v1)
2194 {
2195 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2021040000)
2196     if ((backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 ||
2197          backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH) && target == DNN_TARGET_MYRIAD)
2198         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD);
2199 #endif
2200     testONNXModels("inception_v1", pb);
2201 }
2202
2203 TEST_P(Test_ONNX_nets, Shufflenet)
2204 {
2205 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2021040000)
2206     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
2207     {
2208         if (target == DNN_TARGET_OPENCL_FP16) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
2209         if (target == DNN_TARGET_OPENCL)      applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
2210         if (target == DNN_TARGET_MYRIAD)      applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
2211     }
2212 #endif
2213     testONNXModels("shufflenet", pb);
2214 }
2215
2216 TEST_P(Test_ONNX_nets, Resnet34_kinetics)
2217 {
2218 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2022010000)
2219     // IE exception: Failed to allocate graph: MYRIAD device is not opened
2220     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_MYRIAD)
2221         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
2222     // accuracy
2223     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && (target == DNN_TARGET_OPENCL || target == DNN_TARGET_OPENCL_FP16))
2224         applyTestTag(target == DNN_TARGET_OPENCL ? CV_TEST_TAG_DNN_SKIP_IE_OPENCL : CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16,
2225             CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION
2226         );
2227 #elif defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2021040000)
2228     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
2229     {
2230         // IE exception: Function contains several inputs and outputs with one friendly name!
2231         if (target == DNN_TARGET_MYRIAD)
2232             applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
2233     }
2234 #elif defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2021040000)
2235     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 && target != DNN_TARGET_CPU)
2236         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);  // Only CPU on DLIE backend is supported
2237     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target != DNN_TARGET_CPU)
2238         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);  // Only CPU on DLIE backend is supported
2239 #endif
2240     if (backend == DNN_BACKEND_OPENCV && target != DNN_TARGET_CPU)
2241         throw SkipTestException("Only CPU is supported");  // FIXIT use tags
2242
2243     if (backend == DNN_BACKEND_VKCOM)
2244         applyTestTag(CV_TEST_TAG_DNN_SKIP_VULKAN);
2245
2246     String onnxmodel = findDataFile("dnn/resnet-34_kinetics.onnx", false);
2247     Mat image0 = imread(findDataFile("dnn/dog416.png"));
2248     Mat image1 = imread(findDataFile("dnn/street.png"));
2249
2250     Mat ref0 = blobFromNPY(_tf("data/output_kinetics0.npy"));
2251     Mat ref1 = blobFromNPY(_tf("data/output_kinetics1.npy"));
2252
2253     std::vector<Mat> images_0(16, image0);
2254     std::vector<Mat> images_1(16, image1);
2255     Mat blob0 = blobFromImages(images_0, 1.0, Size(112, 112), Scalar(114.7748, 107.7354, 99.4750), true, true);
2256     Mat blob1 = blobFromImages(images_1, 1.0, Size(112, 112), Scalar(114.7748, 107.7354, 99.4750), true, true);
2257
2258     Net permute;
2259     LayerParams lp;
2260     int order[] = {1, 0, 2, 3};
2261     lp.set("order", DictValue::arrayInt<int*>(&order[0], 4));
2262     permute.addLayerToPrev("perm", "Permute", lp);
2263
2264     permute.setPreferableBackend(backend);
2265     permute.setPreferableTarget(target);
2266
2267     permute.setInput(blob0);
2268     Mat input0 = permute.forward().clone();
2269
2270     permute.setInput(blob1);
2271     Mat input1 = permute.forward().clone();
2272
2273     int dims[] = {1, 3, 16, 112, 112};
2274     input0 = input0.reshape(0, 5, &dims[0]);
2275     input1 = input1.reshape(0, 5, &dims[0]);
2276
2277     Net net = readNetFromONNX(onnxmodel);
2278     ASSERT_FALSE(net.empty());
2279     net.setPreferableBackend(backend);
2280     net.setPreferableTarget(target);
2281
2282     // output range [-5, 11]
2283     float l1 = 0.0013;
2284     float lInf = 0.009;
2285     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_OPENCL_FP16)
2286     {
2287         l1 = 0.02;
2288         lInf = 0.07;
2289     }
2290     if (target == DNN_TARGET_CUDA_FP16)
2291     {
2292         l1 = 0.01;
2293         lInf = 0.06;
2294     }
2295
2296     checkBackend(&input0, &ref0);
2297     net.setInput(input0);
2298     Mat out = net.forward().clone();
2299     normAssert(ref0, out, "", l1, lInf);
2300
2301     checkBackend(&input1, &ref1);
2302     net.setInput(input1);
2303     out = net.forward().clone();
2304     normAssert(ref1, out, "", l1, lInf);
2305
2306     expectNoFallbacksFromIE(net);
2307 }
2308
2309 TEST_P(Test_ONNX_layers, CumSum)
2310 {
2311     testONNXModels("cumsum_1d_exclusive_1");
2312     testONNXModels("cumsum_1d_reverse");
2313     testONNXModels("cumsum_1d_exclusive_1_reverse");
2314     testONNXModels("cumsum_2d_dim_1");
2315     testONNXModels("cumsum_3d_dim_2");
2316 }
2317
2318 INSTANTIATE_TEST_CASE_P(/**/, Test_ONNX_nets, dnnBackendsAndTargets());
2319
2320 }} // namespace