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_13", npy, 0, 0, false, true, 2);
 889     testONNXModels("dynamic_resize_scale_9", npy, 0, 0, false, true, 2);
 890     testONNXModels("dynamic_resize_scale_10", npy, 0, 0, false, true, 2);
 891     testONNXModels("dynamic_resize_scale_11", npy, 0, 0, false, true, 2);
 892     testONNXModels("dynamic_resize_scale_13", npy, 0, 0, false, true, 2);
 893
 894     testONNXModels("resize_size_opset11");
 895     testONNXModels("resize_size_opset13");
 896 }
 897
 898 TEST_P(Test_ONNX_layers, Resize_HumanSeg)
 899 {
 900     testONNXModels("resize_humanseg");
 901 }
 902
 903 TEST_P(Test_ONNX_layers, Div)
 904 {
 905     const String model =  _tf("models/div.onnx");
 906     Net net = readNetFromONNX(model);
 907     ASSERT_FALSE(net.empty());
 908
 909     net.setPreferableBackend(backend);
 910     net.setPreferableTarget(target);
 911
 912     // Reference output values range is -68.80928, 2.991873. So to avoid computational
 913     // difference for FP16 we'll perform reversed division (just swap inputs).
 914     Mat inp1 = blobFromNPY(_tf("data/input_div_1.npy"));
 915     Mat inp2 = blobFromNPY(_tf("data/input_div_0.npy"));
 916     Mat ref  = blobFromNPY(_tf("data/output_div.npy"));
 917     cv::divide(1.0, ref, ref);
 918     checkBackend(&inp1, &ref);
 919
 920     net.setInput(inp1, "0");
 921     net.setInput(inp2, "1");
 922     Mat out = net.forward();
 923
 924     normAssert(ref, out, "", default_l1,  default_lInf);
 925     expectNoFallbacksFromIE(net);
 926     expectNoFallbacksFromCUDA(net);
 927 }
 928
 929 TEST_P(Test_ONNX_layers, DynamicReshape)
 930 {
 931     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
 932         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
 933
 934     testONNXModels("dynamic_reshape");
 935     testONNXModels("dynamic_reshape_opset_11");
 936     testONNXModels("flatten_by_prod");
 937     testONNXModels("flatten_const");
 938 }
 939
 940 TEST_P(Test_ONNX_layers, Reshape)
 941 {
 942     testONNXModels("unsqueeze");
 943     testONNXModels("unsqueeze_opset_13");
 944 }
 945
 946 TEST_P(Test_ONNX_layers, Squeeze)
 947 {
 948     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 && target == DNN_TARGET_MYRIAD)
 949         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
 950     testONNXModels("squeeze");
 951 }
 952
 953 TEST_P(Test_ONNX_layers, ReduceL2)
 954 {
 955     testONNXModels("reduceL2");
 956     testONNXModels("reduceL2_subgraph");
 957     testONNXModels("reduceL2_subgraph_2");
 958     testONNXModels("reduceL2_subgraph2_2");
 959 }
 960
 961 TEST_P(Test_ONNX_layers, Split)
 962 {
 963     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
 964         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
 965     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
 966         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
 967     testONNXModels("split_1");
 968     testONNXModels("split_2");
 969     testONNXModels("split_3");
 970     testONNXModels("split_4");
 971     testONNXModels("split_sizes");
 972     testONNXModels("split_neg_axis");
 973 }
 974
 975 TEST_P(Test_ONNX_layers, Slice)
 976 {
 977 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2019010000)
 978     testONNXModels("slice", npy, 0, 0, false, false);
 979 #else
 980     testONNXModels("slice");
 981     testONNXModels("slice_neg_starts");
 982     testONNXModels("slice_opset_11");
 983 #endif
 984 }
 985
 986 TEST_P(Test_ONNX_layers, Slice_Steps_2DInput)
 987 {
 988     testONNXModels("slice_opset_11_steps_2d");
 989 }
 990
 991 TEST_P(Test_ONNX_layers, Slice_Steps_3DInput)
 992 {
 993     testONNXModels("slice_opset_11_steps_3d");
 994 }
 995
 996 TEST_P(Test_ONNX_layers, Slice_Steps_4DInput)
 997 {
 998     testONNXModels("slice_opset_11_steps_4d");
 999 }
1000
1001 TEST_P(Test_ONNX_layers, Slice_Steps_5DInput)
1002 {
1003     testONNXModels("slice_opset_11_steps_5d");
1004 }
1005
1006 TEST_P(Test_ONNX_layers, Softmax)
1007 {
1008     testONNXModels("softmax");
1009     testONNXModels("log_softmax", npy, 0, 0, false, false);
1010     testONNXModels("softmax_unfused");
1011 }
1012
1013 TEST_P(Test_ONNX_layers, Split_EltwiseMax)
1014 {
1015     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
1016         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
1017     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
1018         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
1019     testONNXModels("split_max");
1020 }
1021
1022 TEST_P(Test_ONNX_layers, LSTM_Activations)
1023 {
1024 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2021040000)
1025     // 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
1026     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && (target == DNN_TARGET_OPENCL || target == DNN_TARGET_OPENCL_FP16))
1027         applyTestTag(target == DNN_TARGET_OPENCL ? CV_TEST_TAG_DNN_SKIP_IE_OPENCL : CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16,
1028             CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION
1029         );
1030 #endif
1031
1032     testONNXModels("lstm_cntk_tanh", pb, 0, 0, false, false);
1033 }
1034
1035 TEST_P(Test_ONNX_layers, LSTM)
1036 {
1037     testONNXModels("lstm", npy, 0, 0, false, false);
1038 }
1039
1040 TEST_P(Test_ONNX_layers, LSTM_bidirectional)
1041 {
1042     testONNXModels("lstm_bidirectional", npy, 0, 0, false, false);
1043 }
1044
1045 TEST_P(Test_ONNX_layers, LSTM_hidden)
1046 {
1047     testONNXModels("hidden_lstm", npy, 0, 0, false, false);
1048 }
1049
1050 TEST_P(Test_ONNX_layers, LSTM_hidden_bidirectional)
1051 {
1052     testONNXModels("hidden_lstm_bi", npy, 0, 0, false, false);
1053 }
1054
1055 TEST_P(Test_ONNX_layers, GRU)
1056 {
1057     testONNXModels("gru", npy, 0, 0, false, false);
1058 }
1059
1060 TEST_P(Test_ONNX_layers, GRU_bidirectional)
1061 {
1062     testONNXModels("gru_bi", npy, 0, 0, false, false);
1063 }
1064
1065 TEST_P(Test_ONNX_layers, Pad2d_Unfused)
1066 {
1067     testONNXModels("ReflectionPad2d");
1068     testONNXModels("ZeroPad2d");
1069 }
1070
1071 TEST_P(Test_ONNX_layers, LinearWithConstant)
1072 {
1073     if (backend == DNN_BACKEND_OPENCV && target == DNN_TARGET_OPENCL_FP16)
1074         applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL_FP16);
1075 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2020040000)
1076     applyTestTag(CV_TEST_TAG_DNN_SKIP_IE);
1077 #endif
1078     if (backend == DNN_BACKEND_CUDA)
1079         applyTestTag(CV_TEST_TAG_DNN_SKIP_CUDA);
1080     testONNXModels("lin_with_constant");
1081 }
1082
1083 TEST_P(Test_ONNX_layers, MatmulWithTwoInputs)
1084 {
1085     if (backend == DNN_BACKEND_OPENCV && target == DNN_TARGET_OPENCL_FP16)
1086         applyTestTag(CV_TEST_TAG_DNN_SKIP_OPENCL_FP16);
1087 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2020040000)
1088     applyTestTag(CV_TEST_TAG_DNN_SKIP_IE);
1089 #endif
1090     testONNXModels("matmul_with_two_inputs");
1091 }
1092
1093 TEST_P(Test_ONNX_layers, ResizeOpset11_Torch1_6)
1094 {
1095     testONNXModels("resize_opset11_torch1.6");
1096 }
1097
1098 TEST_P(Test_ONNX_layers, Mish)
1099 {
1100     testONNXModels("mish");
1101 }
1102
1103 TEST_P(Test_ONNX_layers, CalculatePads)
1104 {
1105     testONNXModels("calc_pads");
1106 }
1107
1108 TEST_P(Test_ONNX_layers, Conv1d)
1109 {
1110     testONNXModels("conv1d");
1111 }
1112
1113 TEST_P(Test_ONNX_layers, Conv1d_bias)
1114 {
1115     testONNXModels("conv1d_bias");
1116 }
1117
1118 TEST_P(Test_ONNX_layers, Conv1d_variable_weight)
1119 {
1120     if (backend == DNN_BACKEND_CUDA)
1121         applyTestTag(CV_TEST_TAG_DNN_SKIP_CUDA); // not supported
1122     if (backend == DNN_BACKEND_VKCOM)
1123         applyTestTag(CV_TEST_TAG_DNN_SKIP_VULKAN); // not supported
1124     String basename = "conv1d_variable_w";
1125     Net net = readNetFromONNX(_tf("models/" + basename + ".onnx"));
1126     ASSERT_FALSE(net.empty());
1127
1128     net.setPreferableBackend(backend);
1129     net.setPreferableTarget(target);
1130
1131     Mat input = blobFromNPY(_tf("data/input_" + basename + "_0.npy"));
1132     Mat weights = blobFromNPY(_tf("data/input_" + basename + "_1.npy"));
1133     Mat ref = blobFromNPY(_tf("data/output_" + basename + ".npy"));
1134
1135     net.setInput(input, "0");
1136     net.setInput(weights, "1");
1137
1138     Mat out = net.forward();
1139     normAssert(ref, out, "", default_l1, default_lInf);
1140 }
1141
1142 TEST_P(Test_ONNX_layers, Conv1d_variable_weight_bias)
1143 {
1144     if (backend == DNN_BACKEND_CUDA)
1145         applyTestTag(CV_TEST_TAG_DNN_SKIP_CUDA); // not supported
1146     if (backend == DNN_BACKEND_VKCOM)
1147         applyTestTag(CV_TEST_TAG_DNN_SKIP_VULKAN); // not supported
1148     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
1149     {
1150         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
1151         if (target == DNN_TARGET_CPU && getInferenceEngineCPUType() == CV_DNN_INFERENCE_ENGINE_CPU_TYPE_ARM_COMPUTE)
1152             applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_ARM_CPU, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
1153     }
1154     String basename = "conv1d_variable_wb";
1155     Net net = readNetFromONNX(_tf("models/" + basename + ".onnx"));
1156     ASSERT_FALSE(net.empty());
1157
1158     net.setPreferableBackend(backend);
1159     net.setPreferableTarget(target);
1160
1161     Mat input = blobFromNPY(_tf("data/input_" + basename + "_0.npy"));
1162     Mat weights = blobFromNPY(_tf("data/input_" + basename + "_1.npy"));
1163     Mat bias = blobFromNPY(_tf("data/input_" + basename + "_2.npy"));
1164     Mat ref = blobFromNPY(_tf("data/output_" + basename + ".npy"));
1165
1166     net.setInput(input, "0");
1167     net.setInput(weights, "1");
1168     net.setInput(bias, "bias");
1169
1170     Mat out = net.forward();
1171     normAssert(ref, out, "", default_l1, default_lInf);
1172 }
1173
1174 TEST_P(Test_ONNX_layers, GatherMultiOutput)
1175 {
1176 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2021040000)
1177     // IE Exception: Ngraph operation Reshape with name 6 has dynamic output shape on 0 port, but CPU plug-in supports only static shape
1178     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && (target == DNN_TARGET_OPENCL || target == DNN_TARGET_OPENCL_FP16))
1179         applyTestTag(target == DNN_TARGET_OPENCL ? CV_TEST_TAG_DNN_SKIP_IE_OPENCL : CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16,
1180             CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION
1181         );
1182 #endif
1183 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2021030000)
1184     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_OPENCL)
1185         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);  // exception
1186     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_OPENCL_FP16)
1187         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);  // exception
1188 #endif
1189
1190 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LE(2021030000)
1191     if (target == DNN_TARGET_MYRIAD)
1192         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE);
1193 #endif
1194
1195     testONNXModels("gather_multi_output");
1196 }
1197
1198 TEST_P(Test_ONNX_layers, DynamicAxes_squeeze_and_conv)
1199 {
1200 #if defined(INF_ENGINE_RELEASE)
1201     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
1202     {
1203         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
1204     }
1205 #if INF_ENGINE_VER_MAJOR_LT(2021000000)
1206     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
1207     {
1208         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
1209     }
1210 #endif
1211 #endif
1212     testONNXModels("squeeze_and_conv_dynamic_axes");
1213 }
1214
1215 TEST_P(Test_ONNX_layers, DynamicAxes_unsqueeze_and_conv)
1216 {
1217 #if defined(INF_ENGINE_RELEASE)
1218     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
1219     {
1220         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
1221     }
1222 #if INF_ENGINE_VER_MAJOR_LT(2021000000)
1223     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
1224     {
1225         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
1226     }
1227 #endif
1228 #endif
1229     testONNXModels("unsqueeze_and_conv_dynamic_axes");
1230 }
1231
1232 TEST_P(Test_ONNX_layers, DynamicAxes_gather)
1233 {
1234 #if defined(INF_ENGINE_RELEASE)
1235     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
1236     {
1237         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
1238     }
1239 #if INF_ENGINE_VER_MAJOR_LT(2021000000)
1240     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
1241     {
1242         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
1243     }
1244 #endif
1245 #endif
1246     testONNXModels("gather_dynamic_axes");
1247 }
1248
1249 TEST_P(Test_ONNX_layers, DynamicAxes_gather_scalar)
1250 {
1251 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2021040000)
1252     // accuracy
1253     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && (target == DNN_TARGET_OPENCL || target == DNN_TARGET_OPENCL_FP16))
1254         applyTestTag(target == DNN_TARGET_OPENCL ? CV_TEST_TAG_DNN_SKIP_IE_OPENCL : CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16,
1255             CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION
1256         );
1257 #endif
1258 #if defined(INF_ENGINE_RELEASE)
1259     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
1260     {
1261         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
1262     }
1263 #if INF_ENGINE_VER_MAJOR_LT(2021000000)
1264     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
1265     {
1266         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
1267     }
1268 #endif
1269 #endif
1270     testONNXModels("gather_scalar_dynamic_axes");
1271 }
1272
1273 TEST_P(Test_ONNX_layers, DynamicAxes_slice)
1274 {
1275 #if defined(INF_ENGINE_RELEASE)
1276     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
1277     {
1278         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
1279     }
1280 #if INF_ENGINE_VER_MAJOR_LT(2021000000)
1281     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
1282     {
1283         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
1284     }
1285 #endif
1286 #endif
1287     testONNXModels("slice_dynamic_axes");
1288 }
1289
1290 TEST_P(Test_ONNX_layers, DynamicAxes_slice_opset_11)
1291 {
1292 #if defined(INF_ENGINE_RELEASE)
1293     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
1294     {
1295         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
1296     }
1297 #if INF_ENGINE_VER_MAJOR_LT(2021000000)
1298     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
1299     {
1300         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
1301     }
1302 #endif
1303 #endif
1304     testONNXModels("slice_opset_11_dynamic_axes");
1305 }
1306
1307 TEST_P(Test_ONNX_layers, DynamicAxes_resize_opset11_torch16)
1308 {
1309 #if defined(INF_ENGINE_RELEASE)
1310     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
1311     {
1312         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
1313     }
1314 #if INF_ENGINE_VER_MAJOR_LT(2021000000)
1315     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
1316     {
1317         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
1318     }
1319 #endif
1320 #endif
1321     testONNXModels("resize_opset11_torch1.6_dynamic_axes");
1322 }
1323
1324 TEST_P(Test_ONNX_layers, DynamicAxes_average_pooling)
1325 {
1326 #if defined(INF_ENGINE_RELEASE)
1327     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
1328     {
1329         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
1330     }
1331 #if INF_ENGINE_VER_MAJOR_LT(2021000000)
1332     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
1333     {
1334         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
1335     }
1336 #endif
1337 #endif
1338     testONNXModels("average_pooling_dynamic_axes");
1339 }
1340
1341 TEST_P(Test_ONNX_layers, DynamicAxes_maxpooling_sigmoid)
1342 {
1343 #if defined(INF_ENGINE_RELEASE)
1344     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
1345     {
1346         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
1347     }
1348 #if INF_ENGINE_VER_MAJOR_LT(2021000000)
1349     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
1350     {
1351         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
1352     }
1353 #endif
1354 #endif
1355     testONNXModels("maxpooling_sigmoid_dynamic_axes");
1356 }
1357
1358 TEST_P(Test_ONNX_layers, DynamicAxes_dynamic_batch)
1359 {
1360 #if defined(INF_ENGINE_RELEASE)
1361     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
1362     {
1363         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
1364     }
1365 #if INF_ENGINE_VER_MAJOR_LT(2021000000)
1366     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
1367     {
1368         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
1369     }
1370 #endif
1371 #endif
1372     testONNXModels("dynamic_batch");
1373 }
1374
1375
1376 TEST_P(Test_ONNX_layers, MaxPool1d)
1377 {
1378 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2021040000)
1379     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
1380     {
1381         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
1382     }
1383     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
1384     {
1385         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
1386     }
1387 #endif
1388 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_GE(2021040000)
1389     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_MYRIAD)
1390     {
1391         // 2021.4: [ GENERAL_ERROR ]  AssertionFailed: !expired()
1392         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
1393     }
1394 #endif
1395     testONNXModels("maxpooling_1d");
1396 }
1397
1398 TEST_P(Test_ONNX_layers, MaxPoolSigmoid1d)
1399 {
1400 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2021040000)
1401     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
1402     {
1403         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
1404     }
1405     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
1406     {
1407         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
1408     }
1409 #endif
1410     testONNXModels("maxpooling_sigmoid_1d");
1411 }
1412
1413 TEST_P(Test_ONNX_layers, MaxPool1d_Twise)
1414 {
1415 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2021040000)
1416     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
1417     {
1418         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
1419     }
1420     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
1421     {
1422         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
1423     }
1424 #endif
1425     testONNXModels("two_maxpooling_1d");
1426 }
1427
1428 TEST_P(Test_ONNX_layers, AvePool1d)
1429 {
1430 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2021040000)
1431     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
1432     {
1433         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
1434     }
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     testONNXModels("average_pooling_1d");
1441 }
1442
1443 TEST_P(Test_ONNX_layers, PoolConv1d)
1444 {
1445 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2021040000)
1446     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
1447     {
1448         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
1449     }
1450     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
1451     {
1452         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
1453     }
1454 #endif
1455     testONNXModels("pool_conv_1d");
1456 }
1457
1458 TEST_P(Test_ONNX_layers, ConvResizePool1d)
1459 {
1460 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2021040000)
1461     // IE Exception: Ngraph operation Reshape with name 15 has dynamic output shape on 0 port, but CPU plug-in supports only static shape
1462     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && (target == DNN_TARGET_OPENCL || target == DNN_TARGET_OPENCL_FP16))
1463         applyTestTag(target == DNN_TARGET_OPENCL ? CV_TEST_TAG_DNN_SKIP_IE_OPENCL : CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16,
1464             CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION
1465         );
1466 #endif
1467 #if defined(INF_ENGINE_RELEASE)
1468     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
1469     {
1470         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
1471     }
1472     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
1473     {
1474         if (target == DNN_TARGET_MYRIAD) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
1475 #if INF_ENGINE_VER_MAJOR_EQ(2021030000)
1476         if (target == DNN_TARGET_OPENCL) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);  // exception
1477         if (target == DNN_TARGET_OPENCL_FP16) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);  // exception
1478 #endif
1479     }
1480 #endif
1481     testONNXModels("conv_resize_pool_1d");
1482 }
1483
1484 TEST_P(Test_ONNX_layers, SubFromConst)
1485 {
1486     testONNXModels("sub_from_const1");
1487     testONNXModels("sub_from_const_eltwise");
1488     testONNXModels("sub_from_const_broadcast");
1489 }
1490
1491 TEST_P(Test_ONNX_layers, DivConst)
1492 {
1493     testONNXModels("div_const");
1494 }
1495
1496
1497 TEST_P(Test_ONNX_layers, Quantized_Convolution)
1498 {
1499     testONNXModels("quantized_conv_uint8_weights", npy, 0.004, 0.02);
1500     testONNXModels("quantized_conv_int8_weights", npy, 0.03, 0.5);
1501     testONNXModels("quantized_conv_per_channel_weights", npy, 0.06, 0.4);
1502 }
1503
1504 TEST_P(Test_ONNX_layers, Quantized_MatMul)
1505 {
1506     testONNXModels("quantized_matmul_uint8_weights", npy, 0.005, 0.007);
1507     testONNXModels("quantized_matmul_int8_weights", npy, 0.06, 0.2);
1508     testONNXModels("quantized_matmul_per_channel_weights", npy, 0.06, 0.22);
1509 }
1510
1511 TEST_P(Test_ONNX_layers, Quantized_MatMul_Variable_Weights)
1512 {
1513     // Unsupported
1514     EXPECT_THROW(
1515     {
1516         testONNXModels("quantized_matmul_variable_inputs");
1517     }, cv::Exception);
1518 }
1519
1520 TEST_P(Test_ONNX_layers, Quantized_Eltwise)
1521 {
1522     testONNXModels("quantized_eltwise");
1523 }
1524
1525 TEST_P(Test_ONNX_layers, Quantized_Eltwise_Scalar)
1526 {
1527     testONNXModels("quantized_eltwise_scalar");
1528 }
1529
1530 TEST_P(Test_ONNX_layers, Quantized_Eltwise_Broadcast)
1531 {
1532     testONNXModels("quantized_eltwise_broadcast");
1533 }
1534
1535 TEST_P(Test_ONNX_layers, Quantized_LeakyReLU)
1536 {
1537     testONNXModels("quantized_leaky_relu");
1538 }
1539
1540 TEST_P(Test_ONNX_layers, Quantized_Sigmoid)
1541 {
1542     testONNXModels("quantized_sigmoid");
1543 }
1544
1545 TEST_P(Test_ONNX_layers, Quantized_MaxPool)
1546 {
1547     testONNXModels("quantized_maxpool");
1548 }
1549
1550 TEST_P(Test_ONNX_layers, Quantized_AvgPool)
1551 {
1552     testONNXModels("quantized_avgpool");
1553 }
1554
1555 TEST_P(Test_ONNX_layers, Quantized_Split)
1556 {
1557     testONNXModels("quantized_split");
1558 }
1559
1560 TEST_P(Test_ONNX_layers, Quantized_Pad)
1561 {
1562     testONNXModels("quantized_padding");
1563 }
1564
1565 TEST_P(Test_ONNX_layers, Quantized_Reshape)
1566 {
1567     testONNXModels("quantized_reshape");
1568 }
1569
1570 TEST_P(Test_ONNX_layers, Quantized_Transpose)
1571 {
1572     testONNXModels("quantized_transpose");
1573 }
1574
1575 TEST_P(Test_ONNX_layers, Quantized_Squeeze)
1576 {
1577     testONNXModels("quantized_squeeze");
1578 }
1579
1580 TEST_P(Test_ONNX_layers, Quantized_Unsqueeze)
1581 {
1582     testONNXModels("quantized_unsqueeze");
1583 }
1584
1585 TEST_P(Test_ONNX_layers, Quantized_Resize)
1586 {
1587     testONNXModels("quantized_resize_nearest");
1588     testONNXModels("quantized_resize_bilinear", npy, 2e-4, 0.003);
1589     testONNXModels("quantized_resize_bilinear_align", npy, 3e-4, 0.003);
1590 }
1591
1592 TEST_P(Test_ONNX_layers, Quantized_Concat)
1593 {
1594     testONNXModels("quantized_concat");
1595     testONNXModels("quantized_concat_const_blob");
1596 }
1597
1598 TEST_P(Test_ONNX_layers, Quantized_Constant)
1599 {
1600     testONNXModels("quantized_constant", npy, 0.002, 0.008);
1601 }
1602
1603 INSTANTIATE_TEST_CASE_P(/*nothing*/, Test_ONNX_layers, dnnBackendsAndTargets());
1604
1605 class Test_ONNX_nets : public Test_ONNX_layers
1606 {
1607 public:
1608     Test_ONNX_nets() { required = false; }
1609 };
1610
1611 TEST_P(Test_ONNX_nets, Alexnet)
1612 {
1613 #if defined(OPENCV_32BIT_CONFIGURATION) && (defined(HAVE_OPENCL) || defined(_WIN32))
1614     applyTestTag(CV_TEST_TAG_MEMORY_2GB);
1615 #else
1616     applyTestTag(target == DNN_TARGET_CPU ? CV_TEST_TAG_MEMORY_512MB : CV_TEST_TAG_MEMORY_1GB);
1617 #endif
1618
1619     const String model =  _tf("models/alexnet.onnx", false);
1620
1621     Net net = readNetFromONNX(model);
1622     ASSERT_FALSE(net.empty());
1623
1624     net.setPreferableBackend(backend);
1625     net.setPreferableTarget(target);
1626
1627     Mat inp = imread(_tf("../grace_hopper_227.png"));
1628     Mat ref = blobFromNPY(_tf("../caffe_alexnet_prob.npy"));
1629     checkBackend(&inp, &ref);
1630
1631     net.setInput(blobFromImage(inp, 1.0f, Size(227, 227), Scalar(), false));
1632     ASSERT_FALSE(net.empty());
1633     Mat out = net.forward();
1634
1635     normAssert(out, ref, "", default_l1,  default_lInf);
1636     expectNoFallbacksFromIE(net);
1637 }
1638
1639 TEST_P(Test_ONNX_nets, Squeezenet)
1640 {
1641     testONNXModels("squeezenet", pb);
1642 }
1643
1644 TEST_P(Test_ONNX_nets, Googlenet)
1645 {
1646 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2021040000)
1647     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
1648         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
1649
1650     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
1651         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
1652 #endif
1653 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2021040000)
1654     // accuracy
1655     if (target == DNN_TARGET_MYRIAD)
1656         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
1657 #endif
1658
1659     const String model = _tf("models/googlenet.onnx", false);
1660
1661     Net net = readNetFromONNX(model);
1662     ASSERT_FALSE(net.empty());
1663
1664     net.setPreferableBackend(backend);
1665     net.setPreferableTarget(target);
1666
1667     std::vector<Mat> images;
1668     images.push_back( imread(_tf("../googlenet_0.png")) );
1669     images.push_back( imread(_tf("../googlenet_1.png")) );
1670     Mat inp = blobFromImages(images, 1.0f, Size(), Scalar(), false);
1671     Mat ref = blobFromNPY(_tf("../googlenet_prob.npy"));
1672     checkBackend(&inp, &ref);
1673
1674     net.setInput(inp);
1675     ASSERT_FALSE(net.empty());
1676     Mat out = net.forward();
1677
1678     normAssert(ref, out, "", default_l1,  default_lInf);
1679     expectNoFallbacksFromIE(net);
1680 }
1681
1682 TEST_P(Test_ONNX_nets, CaffeNet)
1683 {
1684 #if defined(OPENCV_32BIT_CONFIGURATION) && (defined(HAVE_OPENCL) || defined(_WIN32))
1685     applyTestTag(CV_TEST_TAG_MEMORY_2GB);
1686 #else
1687     applyTestTag(target == DNN_TARGET_CPU ? CV_TEST_TAG_MEMORY_512MB : CV_TEST_TAG_MEMORY_1GB);
1688 #endif
1689
1690 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2019030000)
1691     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 && target == DNN_TARGET_MYRIAD
1692         && getInferenceEngineVPUType() == CV_DNN_INFERENCE_ENGINE_VPU_TYPE_MYRIAD_X)
1693         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD_X, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
1694 #endif
1695     testONNXModels("caffenet", pb);
1696 }
1697
1698 TEST_P(Test_ONNX_nets, RCNN_ILSVRC13)
1699 {
1700 #if defined(OPENCV_32BIT_CONFIGURATION) && (defined(HAVE_OPENCL) || defined(_WIN32))
1701     applyTestTag(CV_TEST_TAG_MEMORY_2GB);
1702 #else
1703     applyTestTag(target == DNN_TARGET_CPU ? CV_TEST_TAG_MEMORY_512MB : CV_TEST_TAG_MEMORY_1GB);
1704 #endif
1705
1706 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2019030000)
1707     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 && target == DNN_TARGET_MYRIAD
1708         && getInferenceEngineVPUType() == CV_DNN_INFERENCE_ENGINE_VPU_TYPE_MYRIAD_X)
1709         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD_X, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
1710 #endif
1711     // Reference output values are in range [-4.992, -1.161]
1712     testONNXModels("rcnn_ilsvrc13", pb, 0.0046);
1713 }
1714
1715 TEST_P(Test_ONNX_nets, VGG16_bn)
1716 {
1717     applyTestTag(CV_TEST_TAG_MEMORY_6GB);  // > 2.3Gb
1718
1719     // output range: [-16; 27], after Softmax [0; 0.67]
1720     const double lInf = (target == DNN_TARGET_MYRIAD) ? 0.038 : default_lInf;
1721     testONNXModels("vgg16-bn", pb, default_l1, lInf, true);
1722 }
1723
1724 TEST_P(Test_ONNX_nets, ZFNet)
1725 {
1726     applyTestTag(CV_TEST_TAG_MEMORY_2GB);
1727     testONNXModels("zfnet512", pb);
1728 }
1729
1730 TEST_P(Test_ONNX_nets, ResNet18v1)
1731 {
1732     applyTestTag(CV_TEST_TAG_MEMORY_512MB);
1733
1734     // output range: [-16; 22], after Softmax [0, 0.51]
1735     testONNXModels("resnet18v1", pb, default_l1, default_lInf, true, target != DNN_TARGET_MYRIAD);
1736 }
1737
1738 TEST_P(Test_ONNX_nets, ResNet50v1)
1739 {
1740     applyTestTag(CV_TEST_TAG_MEMORY_512MB);
1741
1742     // output range: [-67; 75], after Softmax [0, 0.98]
1743     testONNXModels("resnet50v1", pb, default_l1, default_lInf, true, target != DNN_TARGET_MYRIAD);
1744 }
1745
1746 TEST_P(Test_ONNX_nets, ResNet50_Int8)
1747 {
1748     testONNXModels("resnet50_int8", pb, default_l1, default_lInf, true);
1749 }
1750
1751 TEST_P(Test_ONNX_nets, ResNet101_DUC_HDC)
1752 {
1753     applyTestTag(CV_TEST_TAG_VERYLONG);
1754
1755 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_GE(2019010000)
1756     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
1757         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
1758 #endif
1759 #if defined(INF_ENGINE_RELEASE)
1760     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 && target == DNN_TARGET_MYRIAD)
1761         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
1762 #endif
1763     if (target == DNN_TARGET_OPENCL_FP16 || target == DNN_TARGET_OPENCL)
1764     {
1765         if (backend == DNN_BACKEND_OPENCV)
1766             applyTestTag(target == DNN_TARGET_OPENCL ? CV_TEST_TAG_DNN_SKIP_OPENCL : CV_TEST_TAG_DNN_SKIP_OPENCL_FP16);
1767         throw SkipTestException("Test is disabled for OpenCL targets");
1768     }
1769     testONNXModels("resnet101_duc_hdc", pb);
1770 }
1771
1772 TEST_P(Test_ONNX_nets, TinyYolov2)
1773 {
1774     applyTestTag(CV_TEST_TAG_MEMORY_512MB);
1775
1776     if (cvtest::skipUnstableTests)
1777         throw SkipTestException("Skip unstable test");
1778 #if defined(INF_ENGINE_RELEASE)
1779     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019
1780             && (target == DNN_TARGET_OPENCL || target == DNN_TARGET_OPENCL_FP16)
1781     )
1782         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);
1783
1784     if (target == DNN_TARGET_MYRIAD && getInferenceEngineVPUType() == CV_DNN_INFERENCE_ENGINE_VPU_TYPE_MYRIAD_X
1785     )
1786         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD_X,
1787                      backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 ?
1788                      CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER :
1789                      CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
1790 #endif
1791
1792     // output range: [-11; 8]
1793     double l1 =  default_l1, lInf = default_lInf;
1794     if (target == DNN_TARGET_OPENCL_FP16 || target == DNN_TARGET_MYRIAD)
1795     {
1796         l1 = 0.02;
1797         lInf = 0.2;
1798     }
1799     else if (target == DNN_TARGET_CUDA_FP16)
1800     {
1801         l1 = 0.018;
1802         lInf = 0.16;
1803     }
1804 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2020040000)
1805     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_OPENCL_FP16)
1806     {
1807         l1 = 0.018f; lInf = 0.16f;
1808     }
1809 #endif
1810
1811     testONNXModels("tiny_yolo2", pb, l1, lInf);
1812 }
1813
1814 TEST_P(Test_ONNX_nets, CNN_MNIST)
1815 {
1816     // output range: [-1952; 6574], after Softmax [0; 1]
1817     testONNXModels("cnn_mnist", pb, default_l1, default_lInf, true);
1818 }
1819
1820 TEST_P(Test_ONNX_nets, MobileNet_v2)
1821 {
1822     // output range: [-166; 317], after Softmax [0; 1]
1823     testONNXModels("mobilenetv2", pb, default_l1, default_lInf, true);
1824 }
1825
1826 TEST_P(Test_ONNX_nets, LResNet100E_IR)
1827 {
1828     applyTestTag(
1829 #if defined(OPENCV_32BIT_CONFIGURATION) && defined(HAVE_OPENCL)
1830         CV_TEST_TAG_MEMORY_2GB,
1831 #else
1832         (target == DNN_TARGET_CPU ? CV_TEST_TAG_MEMORY_512MB : CV_TEST_TAG_MEMORY_1GB),
1833 #endif
1834         CV_TEST_TAG_DEBUG_LONG
1835     );
1836     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
1837     {
1838         if (target == DNN_TARGET_OPENCL_FP16) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
1839         if (target == DNN_TARGET_OPENCL)      applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
1840         if (target == DNN_TARGET_MYRIAD)      applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
1841     }
1842     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
1843     {
1844         if (target == DNN_TARGET_OPENCL_FP16) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
1845         if (target == DNN_TARGET_OPENCL)      applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
1846         if (target == DNN_TARGET_MYRIAD)      applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
1847     }
1848
1849     double l1 = default_l1, lInf = default_lInf;
1850     // output range: [-3; 3]
1851     if (backend == DNN_BACKEND_OPENCV && target == DNN_TARGET_OPENCL_FP16)
1852     {
1853         l1 = 0.009;
1854         lInf = 0.035;
1855     }
1856     else if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 && target == DNN_TARGET_CPU)
1857     {
1858         l1 = 4.6e-5;
1859         lInf = 1.9e-4;
1860     }
1861     else if (target == DNN_TARGET_CUDA_FP16)
1862     {
1863         l1 = 0.008;
1864         lInf = 0.04;
1865     }
1866     testONNXModels("LResNet100E_IR", pb, l1, lInf);
1867 }
1868
1869 TEST_P(Test_ONNX_nets, Emotion_ferplus)
1870 {
1871 #if defined(INF_ENGINE_RELEASE)
1872     if (target == DNN_TARGET_MYRIAD && getInferenceEngineVPUType() == CV_DNN_INFERENCE_ENGINE_VPU_TYPE_MYRIAD_X)
1873         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD_X,
1874                      backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 ?
1875                      CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER :
1876                      CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);
1877 #endif
1878
1879     double l1 = default_l1;
1880     double lInf = default_lInf;
1881
1882     // Output values are in range [-2.011, 2.111]
1883     if (backend == DNN_BACKEND_OPENCV && target == DNN_TARGET_OPENCL_FP16)
1884         l1 = 0.007;
1885     else if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 && target == DNN_TARGET_OPENCL_FP16)
1886     {
1887         l1 = 0.021;
1888         lInf = 0.034;
1889     }
1890     else if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 && (target == DNN_TARGET_CPU || target == DNN_TARGET_OPENCL)) {
1891         l1 = 2.4e-4;
1892         lInf = 6e-4;
1893     }
1894 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_GE(2020040000)
1895     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_OPENCL_FP16)
1896     {
1897         l1 = 0.013f; lInf = 0.035f;
1898     }
1899 #endif
1900
1901     testONNXModels("emotion_ferplus", pb, l1, lInf);
1902 }
1903
1904 TEST_P(Test_ONNX_nets, Inception_v2)
1905 {
1906     testONNXModels("inception_v2", pb, default_l1, default_lInf, true);
1907 }
1908
1909 TEST_P(Test_ONNX_nets, DenseNet121)
1910 {
1911     applyTestTag(CV_TEST_TAG_MEMORY_512MB);
1912
1913     // output range: [-87; 138], after Softmax [0; 1]
1914     testONNXModels("densenet121", pb, default_l1, default_lInf, true, target != DNN_TARGET_MYRIAD);
1915 }
1916
1917 TEST_P(Test_ONNX_nets, Inception_v1)
1918 {
1919 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2021040000)
1920     if ((backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 ||
1921          backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH) && target == DNN_TARGET_MYRIAD)
1922         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD);
1923 #endif
1924     testONNXModels("inception_v1", pb);
1925 }
1926
1927 TEST_P(Test_ONNX_nets, Shufflenet)
1928 {
1929 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2021040000)
1930     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019)
1931     {
1932         if (target == DNN_TARGET_OPENCL_FP16) applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL_FP16, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
1933         if (target == DNN_TARGET_OPENCL)      applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_OPENCL, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
1934         if (target == DNN_TARGET_MYRIAD)      applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);
1935     }
1936 #endif
1937     testONNXModels("shufflenet", pb);
1938 }
1939
1940 TEST_P(Test_ONNX_nets, Resnet34_kinetics)
1941 {
1942 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2021040000)
1943     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 && target != DNN_TARGET_CPU)
1944         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NN_BUILDER);  // Only CPU on DLIE backend is supported
1945     else if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target != DNN_TARGET_CPU)
1946         applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_NGRAPH);  // Only CPU on DLIE backend is supported
1947 #endif
1948 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_EQ(2021040000)
1949     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)
1950     {
1951         // IE exception: Function contains several inputs and outputs with one friendly name!
1952         if (target == DNN_TARGET_MYRIAD)
1953             applyTestTag(CV_TEST_TAG_DNN_SKIP_IE_MYRIAD, CV_TEST_TAG_DNN_SKIP_IE_NGRAPH, CV_TEST_TAG_DNN_SKIP_IE_VERSION);
1954     }
1955 #endif
1956     if (backend == DNN_BACKEND_OPENCV && target != DNN_TARGET_CPU)
1957         throw SkipTestException("Only CPU is supported");  // FIXIT use tags
1958
1959     if (backend == DNN_BACKEND_VKCOM)
1960         applyTestTag(CV_TEST_TAG_DNN_SKIP_VULKAN);
1961
1962     String onnxmodel = findDataFile("dnn/resnet-34_kinetics.onnx", false);
1963     Mat image0 = imread(findDataFile("dnn/dog416.png"));
1964     Mat image1 = imread(findDataFile("dnn/street.png"));
1965
1966     Mat ref0 = blobFromNPY(_tf("data/output_kinetics0.npy"));
1967     Mat ref1 = blobFromNPY(_tf("data/output_kinetics1.npy"));
1968
1969     std::vector<Mat> images_0(16, image0);
1970     std::vector<Mat> images_1(16, image1);
1971     Mat blob0 = blobFromImages(images_0, 1.0, Size(112, 112), Scalar(114.7748, 107.7354, 99.4750), true, true);
1972     Mat blob1 = blobFromImages(images_1, 1.0, Size(112, 112), Scalar(114.7748, 107.7354, 99.4750), true, true);
1973
1974     Net permute;
1975     LayerParams lp;
1976     int order[] = {1, 0, 2, 3};
1977     lp.set("order", DictValue::arrayInt<int*>(&order[0], 4));
1978     permute.addLayerToPrev("perm", "Permute", lp);
1979
1980     permute.setPreferableBackend(backend);
1981     permute.setPreferableTarget(target);
1982
1983     permute.setInput(blob0);
1984     Mat input0 = permute.forward().clone();
1985
1986     permute.setInput(blob1);
1987     Mat input1 = permute.forward().clone();
1988
1989     int dims[] = {1, 3, 16, 112, 112};
1990     input0 = input0.reshape(0, 5, &dims[0]);
1991     input1 = input1.reshape(0, 5, &dims[0]);
1992
1993     Net net = readNetFromONNX(onnxmodel);
1994     ASSERT_FALSE(net.empty());
1995     net.setPreferableBackend(backend);
1996     net.setPreferableTarget(target);
1997
1998     // output range [-5, 11]
1999     float l1 = 0.0013;
2000     float lInf = 0.009;
2001     if (backend == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH && target == DNN_TARGET_OPENCL_FP16)
2002     {
2003         l1 = 0.02;
2004         lInf = 0.07;
2005     }
2006     if (target == DNN_TARGET_CUDA_FP16)
2007     {
2008         l1 = 0.01;
2009         lInf = 0.06;
2010     }
2011
2012     checkBackend(&input0, &ref0);
2013     net.setInput(input0);
2014     Mat out = net.forward().clone();
2015     normAssert(ref0, out, "", l1, lInf);
2016
2017     checkBackend(&input1, &ref1);
2018     net.setInput(input1);
2019     out = net.forward().clone();
2020     normAssert(ref1, out, "", l1, lInf);
2021
2022     expectNoFallbacksFromIE(net);
2023 }
2024
2025 TEST_P(Test_ONNX_layers, CumSum)
2026 {
2027     testONNXModels("cumsum_1d_exclusive_1");
2028     testONNXModels("cumsum_1d_reverse");
2029     testONNXModels("cumsum_1d_exclusive_1_reverse");
2030     testONNXModels("cumsum_2d_dim_1");
2031     testONNXModels("cumsum_3d_dim_2");
2032 }
2033
2034 INSTANTIATE_TEST_CASE_P(/**/, Test_ONNX_nets, dnnBackendsAndTargets());
2035
2036 }} // namespace