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