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