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)
  36     {
  37         String onnxmodel = _tf("models/" + basename + ".onnx", required);
  38         Mat inp, ref;
  39         if (ext == npy) {
  40             inp = blobFromNPY(_tf("data/input_" + basename + ".npy"));
  41             ref = blobFromNPY(_tf("data/output_" + basename + ".npy"));
  42         }
  43         else if (ext == pb) {
  44             inp = readTensorFromONNX(_tf("data/input_" + basename + ".pb"));
  45             ref = readTensorFromONNX(_tf("data/output_" + basename + ".pb"));
  46         }
  47         else
  48             CV_Error(Error::StsUnsupportedFormat, "Unsupported extension");
  49
  50         checkBackend(&inp, &ref);
  51         Net net = readNetFromONNX(onnxmodel);
  52         ASSERT_FALSE(net.empty());
  53
  54         net.setPreferableBackend(backend);
  55         net.setPreferableTarget(target);
  56
  57         net.setInput(inp);
  58         Mat out = net.forward("");
  59
  60         if (useSoftmax)
  61         {
  62             LayerParams lp;
  63             Net netSoftmax;
  64             netSoftmax.addLayerToPrev("softmaxLayer", "SoftMax", lp);
  65             netSoftmax.setPreferableBackend(DNN_BACKEND_OPENCV);
  66
  67             netSoftmax.setInput(out);
  68             out = netSoftmax.forward();
  69
  70             netSoftmax.setInput(ref);
  71             ref = netSoftmax.forward();
  72         }
  73         normAssert(ref, out, "", l1 ? l1 : default_l1, lInf ? lInf : default_lInf);
  74         if (checkNoFallbacks)
  75             expectNoFallbacksFromIE(net);
  76     }
  77 };
  78
  79 TEST_P(Test_ONNX_layers, MaxPooling)
  80 {
  81     testONNXModels("maxpooling");
  82     testONNXModels("two_maxpooling");
  83 }
  84
  85 TEST_P(Test_ONNX_layers, Convolution)
  86 {
  87     testONNXModels("convolution");
  88 }
  89
  90 TEST_P(Test_ONNX_layers, Convolution3D)
  91 {
  92 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2019010000)
  93     throw SkipTestException("Test is enabled starts from 2019R1");
  94 #endif
  95     if (backend != DNN_BACKEND_INFERENCE_ENGINE || target != DNN_TARGET_CPU)
  96         throw SkipTestException("Only DLIE backend on CPU is supported");
  97     testONNXModels("conv3d");
  98     testONNXModels("conv3d_bias");
  99 }
 100
 101 TEST_P(Test_ONNX_layers, Two_convolution)
 102 {
 103 #if defined(INF_ENGINE_RELEASE)
 104     if (backend == DNN_BACKEND_INFERENCE_ENGINE && target == DNN_TARGET_MYRIAD
 105         && getInferenceEngineVPUType() == CV_DNN_INFERENCE_ENGINE_VPU_TYPE_MYRIAD_X
 106     )
 107         throw SkipTestException("Test is disabled for MyriadX"); // 2018R5+ is failed
 108 #endif
 109     // Reference output values are in range [-0.855, 0.611]
 110     testONNXModels("two_convolution");
 111 }
 112
 113 TEST_P(Test_ONNX_layers, Deconvolution)
 114 {
 115     testONNXModels("deconvolution", npy, 0, 0, false, false);
 116     testONNXModels("two_deconvolution", npy, 0, 0, false, false);
 117     testONNXModels("deconvolution_group", npy, 0, 0, false, false);
 118     testONNXModels("deconvolution_output_shape", npy, 0, 0, false, false);
 119     testONNXModels("deconv_adjpad_2d", npy, 0, 0, false, false);
 120 }
 121
 122 TEST_P(Test_ONNX_layers, Dropout)
 123 {
 124     testONNXModels("dropout");
 125 }
 126
 127 TEST_P(Test_ONNX_layers, Linear)
 128 {
 129     if (backend == DNN_BACKEND_OPENCV && target == DNN_TARGET_OPENCL_FP16)
 130         throw SkipTestException("");
 131     testONNXModels("linear");
 132 }
 133
 134 TEST_P(Test_ONNX_layers, ReLU)
 135 {
 136     testONNXModels("ReLU");
 137 }
 138
 139 TEST_P(Test_ONNX_layers, MaxPooling_Sigmoid)
 140 {
 141     testONNXModels("maxpooling_sigmoid");
 142 }
 143
 144 TEST_P(Test_ONNX_layers, Concatenation)
 145 {
 146     if (backend == DNN_BACKEND_INFERENCE_ENGINE &&
 147          (target == DNN_TARGET_OPENCL_FP16 || target == DNN_TARGET_OPENCL || target == DNN_TARGET_MYRIAD))
 148         throw SkipTestException("");
 149     testONNXModels("concatenation");
 150 }
 151
 152 TEST_P(Test_ONNX_layers, Eltwise3D)
 153 {
 154 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2019010000)
 155     throw SkipTestException("Test is enabled starts from 2019R1");
 156 #endif
 157     if (backend == DNN_BACKEND_INFERENCE_ENGINE && target != DNN_TARGET_CPU)
 158         throw SkipTestException("Only CPU on DLIE backend is supported");
 159     testONNXModels("eltwise3d");
 160 }
 161
 162 TEST_P(Test_ONNX_layers, AveragePooling)
 163 {
 164     testONNXModels("average_pooling");
 165 }
 166
 167 TEST_P(Test_ONNX_layers, MaxPooling3D)
 168 {
 169 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2019010000)
 170     throw SkipTestException("Test is enabled starts from 2019R1");
 171 #endif
 172     if (backend != DNN_BACKEND_INFERENCE_ENGINE || target != DNN_TARGET_CPU)
 173         throw SkipTestException("Only DLIE backend on CPU is supported");
 174     testONNXModels("max_pool3d");
 175 }
 176
 177 TEST_P(Test_ONNX_layers, AvePooling3D)
 178 {
 179 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2019010000)
 180     throw SkipTestException("Test is enabled starts from 2019R1");
 181 #endif
 182     if (backend != DNN_BACKEND_INFERENCE_ENGINE || target != DNN_TARGET_CPU)
 183         throw SkipTestException("Only DLIE backend on CPU is supported");
 184     testONNXModels("ave_pool3d");
 185 }
 186
 187 TEST_P(Test_ONNX_layers, BatchNormalization)
 188 {
 189     testONNXModels("batch_norm");
 190 }
 191
 192 TEST_P(Test_ONNX_layers, BatchNormalization3D)
 193 {
 194     if (backend == DNN_BACKEND_INFERENCE_ENGINE && target != DNN_TARGET_CPU)
 195         throw SkipTestException("");
 196     testONNXModels("batch_norm_3d");
 197 }
 198
 199 TEST_P(Test_ONNX_layers, Transpose)
 200 {
 201     if (backend == DNN_BACKEND_INFERENCE_ENGINE &&
 202          (target == DNN_TARGET_OPENCL_FP16 || target == DNN_TARGET_OPENCL || target == DNN_TARGET_MYRIAD))
 203         throw SkipTestException("");
 204     testONNXModels("transpose");
 205 }
 206
 207 TEST_P(Test_ONNX_layers, Multiplication)
 208 {
 209     if ((backend == DNN_BACKEND_OPENCV && target == DNN_TARGET_OPENCL_FP16) ||
 210         (backend == DNN_BACKEND_INFERENCE_ENGINE && target == DNN_TARGET_MYRIAD))
 211         throw SkipTestException("");
 212     testONNXModels("mul");
 213 }
 214
 215 TEST_P(Test_ONNX_layers, Constant)
 216 {
 217 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LE(2018050000)
 218     if (backend == DNN_BACKEND_INFERENCE_ENGINE && target == DNN_TARGET_MYRIAD
 219             && getInferenceEngineVPUType() == CV_DNN_INFERENCE_ENGINE_VPU_TYPE_MYRIAD_X)
 220        throw SkipTestException("Test is disabled for OpenVINO <= 2018R5 + MyriadX target");
 221 #endif
 222     testONNXModels("constant");
 223 }
 224
 225 TEST_P(Test_ONNX_layers, Padding)
 226 {
 227 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2019010000)
 228     testONNXModels("padding", npy, 0, 0, false, false);
 229 #else
 230     testONNXModels("padding");
 231 #endif
 232 }
 233
 234 TEST_P(Test_ONNX_layers, Resize)
 235 {
 236     testONNXModels("resize_nearest");
 237 }
 238
 239 TEST_P(Test_ONNX_layers, MultyInputs)
 240 {
 241     const String model =  _tf("models/multy_inputs.onnx");
 242
 243     Net net = readNetFromONNX(model);
 244     ASSERT_FALSE(net.empty());
 245
 246     net.setPreferableBackend(backend);
 247     net.setPreferableTarget(target);
 248
 249     Mat inp1 = blobFromNPY(_tf("data/input_multy_inputs_0.npy"));
 250     Mat inp2 = blobFromNPY(_tf("data/input_multy_inputs_1.npy"));
 251     Mat ref  = blobFromNPY(_tf("data/output_multy_inputs.npy"));
 252     checkBackend(&inp1, &ref);
 253
 254     net.setInput(inp1, "0");
 255     net.setInput(inp2, "1");
 256     Mat out = net.forward();
 257
 258     normAssert(ref, out, "", default_l1,  default_lInf);
 259     expectNoFallbacksFromIE(net);
 260 }
 261
 262 TEST_P(Test_ONNX_layers, DynamicReshape)
 263 {
 264     if (backend == DNN_BACKEND_INFERENCE_ENGINE && (target == DNN_TARGET_OPENCL || target == DNN_TARGET_OPENCL_FP16))
 265         throw SkipTestException("");
 266     testONNXModels("dynamic_reshape");
 267 }
 268
 269 TEST_P(Test_ONNX_layers, Reshape)
 270 {
 271     testONNXModels("unsqueeze");
 272 }
 273
 274 TEST_P(Test_ONNX_layers, Slice)
 275 {
 276 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2019010000)
 277     testONNXModels("slice", npy, 0, 0, false, false);
 278 #else
 279     testONNXModels("slice");
 280 #endif
 281 }
 282
 283 TEST_P(Test_ONNX_layers, Softmax)
 284 {
 285     testONNXModels("softmax");
 286     testONNXModels("log_softmax", npy, 0, 0, false, false);
 287 }
 288
 289 INSTANTIATE_TEST_CASE_P(/*nothing*/, Test_ONNX_layers, dnnBackendsAndTargets());
 290
 291 class Test_ONNX_nets : public Test_ONNX_layers
 292 {
 293 public:
 294     Test_ONNX_nets() { required = false; }
 295 };
 296
 297 TEST_P(Test_ONNX_nets, Alexnet)
 298 {
 299     applyTestTag(target == DNN_TARGET_CPU ? CV_TEST_TAG_MEMORY_512MB : CV_TEST_TAG_MEMORY_1GB);
 300     const String model =  _tf("models/alexnet.onnx", false);
 301
 302     Net net = readNetFromONNX(model);
 303     ASSERT_FALSE(net.empty());
 304
 305     net.setPreferableBackend(backend);
 306     net.setPreferableTarget(target);
 307
 308     Mat inp = imread(_tf("../grace_hopper_227.png"));
 309     Mat ref = blobFromNPY(_tf("../caffe_alexnet_prob.npy"));
 310     checkBackend(&inp, &ref);
 311
 312     net.setInput(blobFromImage(inp, 1.0f, Size(227, 227), Scalar(), false));
 313     ASSERT_FALSE(net.empty());
 314     Mat out = net.forward();
 315
 316     normAssert(out, ref, "", default_l1,  default_lInf);
 317     expectNoFallbacksFromIE(net);
 318 }
 319
 320 TEST_P(Test_ONNX_nets, Squeezenet)
 321 {
 322     testONNXModels("squeezenet", pb);
 323 }
 324
 325 TEST_P(Test_ONNX_nets, Googlenet)
 326 {
 327     if (backend == DNN_BACKEND_INFERENCE_ENGINE)
 328         throw SkipTestException("");
 329
 330     const String model = _tf("models/googlenet.onnx", false);
 331
 332     Net net = readNetFromONNX(model);
 333     ASSERT_FALSE(net.empty());
 334
 335     net.setPreferableBackend(backend);
 336     net.setPreferableTarget(target);
 337
 338     std::vector<Mat> images;
 339     images.push_back( imread(_tf("../googlenet_0.png")) );
 340     images.push_back( imread(_tf("../googlenet_1.png")) );
 341     Mat inp = blobFromImages(images, 1.0f, Size(), Scalar(), false);
 342     Mat ref = blobFromNPY(_tf("../googlenet_prob.npy"));
 343     checkBackend(&inp, &ref);
 344
 345     net.setInput(inp);
 346     ASSERT_FALSE(net.empty());
 347     Mat out = net.forward();
 348
 349     normAssert(ref, out, "", default_l1,  default_lInf);
 350     expectNoFallbacksFromIE(net);
 351 }
 352
 353 TEST_P(Test_ONNX_nets, CaffeNet)
 354 {
 355     applyTestTag(target == DNN_TARGET_CPU ? CV_TEST_TAG_MEMORY_512MB : CV_TEST_TAG_MEMORY_1GB);
 356     testONNXModels("caffenet", pb);
 357 }
 358
 359 TEST_P(Test_ONNX_nets, RCNN_ILSVRC13)
 360 {
 361     applyTestTag(target == DNN_TARGET_CPU ? CV_TEST_TAG_MEMORY_512MB : CV_TEST_TAG_MEMORY_1GB);
 362
 363     // Reference output values are in range [-4.992, -1.161]
 364     testONNXModels("rcnn_ilsvrc13", pb, 0.0045);
 365 }
 366
 367 TEST_P(Test_ONNX_nets, VGG16)
 368 {
 369     applyTestTag(CV_TEST_TAG_MEMORY_6GB);  // > 2.3Gb
 370
 371     // output range: [-69; 72], after Softmax [0; 0.96]
 372     testONNXModels("vgg16", pb, default_l1, default_lInf, true);
 373 }
 374
 375 TEST_P(Test_ONNX_nets, VGG16_bn)
 376 {
 377     applyTestTag(CV_TEST_TAG_MEMORY_6GB);  // > 2.3Gb
 378
 379     // output range: [-16; 27], after Softmax [0; 0.67]
 380     const double lInf = (target == DNN_TARGET_MYRIAD) ? 0.038 : default_lInf;
 381     testONNXModels("vgg16-bn", pb, default_l1, lInf, true);
 382 }
 383
 384 TEST_P(Test_ONNX_nets, ZFNet)
 385 {
 386     applyTestTag(CV_TEST_TAG_MEMORY_2GB);
 387     testONNXModels("zfnet512", pb);
 388 }
 389
 390 TEST_P(Test_ONNX_nets, ResNet18v1)
 391 {
 392     applyTestTag(CV_TEST_TAG_MEMORY_512MB);
 393
 394     // output range: [-16; 22], after Softmax [0, 0.51]
 395     testONNXModels("resnet18v1", pb, default_l1, default_lInf, true, target != DNN_TARGET_MYRIAD);
 396 }
 397
 398 TEST_P(Test_ONNX_nets, ResNet50v1)
 399 {
 400     applyTestTag(CV_TEST_TAG_MEMORY_512MB);
 401
 402     // output range: [-67; 75], after Softmax [0, 0.98]
 403     testONNXModels("resnet50v1", pb, default_l1, default_lInf, true, target != DNN_TARGET_MYRIAD);
 404 }
 405
 406 TEST_P(Test_ONNX_nets, ResNet101_DUC_HDC)
 407 {
 408     applyTestTag(CV_TEST_TAG_VERYLONG);
 409
 410 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_GE(2019010000)
 411     if (backend == DNN_BACKEND_INFERENCE_ENGINE)
 412         throw SkipTestException("Test is disabled for DLIE targets");
 413 #endif
 414 #if defined(INF_ENGINE_RELEASE)
 415     if (backend == DNN_BACKEND_INFERENCE_ENGINE && target == DNN_TARGET_MYRIAD)
 416         throw SkipTestException("Test is disabled for Myriad targets");
 417 #endif
 418     if (target == DNN_TARGET_OPENCL_FP16 || target == DNN_TARGET_OPENCL)
 419         throw SkipTestException("Test is disabled for OpenCL targets");
 420     testONNXModels("resnet101_duc_hdc", pb);
 421 }
 422
 423 TEST_P(Test_ONNX_nets, TinyYolov2)
 424 {
 425     applyTestTag(CV_TEST_TAG_MEMORY_512MB);
 426
 427     if (cvtest::skipUnstableTests)
 428         throw SkipTestException("Skip unstable test");
 429 #if defined(INF_ENGINE_RELEASE)
 430     if (backend == DNN_BACKEND_INFERENCE_ENGINE
 431             && (target == DNN_TARGET_OPENCL || target == DNN_TARGET_OPENCL_FP16)
 432     )
 433         throw SkipTestException("Test is disabled for DLIE OpenCL targets");
 434
 435     if (backend == DNN_BACKEND_INFERENCE_ENGINE && target == DNN_TARGET_MYRIAD
 436             && getInferenceEngineVPUType() == CV_DNN_INFERENCE_ENGINE_VPU_TYPE_MYRIAD_X
 437     )
 438         throw SkipTestException("Test is disabled for MyriadX");
 439 #endif
 440
 441     // output range: [-11; 8]
 442     double l1 = (target == DNN_TARGET_OPENCL_FP16 || target == DNN_TARGET_MYRIAD) ? 0.017 : default_l1;
 443     double lInf = (target == DNN_TARGET_OPENCL_FP16 || target == DNN_TARGET_MYRIAD) ? 0.14 : default_lInf;
 444     testONNXModels("tiny_yolo2", pb, l1, lInf);
 445 }
 446
 447 TEST_P(Test_ONNX_nets, CNN_MNIST)
 448 {
 449     // output range: [-1952; 6574], after Softmax [0; 1]
 450     testONNXModels("cnn_mnist", pb, default_l1, default_lInf, true);
 451 }
 452
 453 TEST_P(Test_ONNX_nets, MobileNet_v2)
 454 {
 455     // output range: [-166; 317], after Softmax [0; 1]
 456     testONNXModels("mobilenetv2", pb, default_l1, default_lInf, true);
 457 }
 458
 459 TEST_P(Test_ONNX_nets, LResNet100E_IR)
 460 {
 461     applyTestTag(
 462         (target == DNN_TARGET_CPU ? CV_TEST_TAG_MEMORY_512MB : CV_TEST_TAG_MEMORY_1GB),
 463         CV_TEST_TAG_DEBUG_LONG
 464     );
 465     if (backend == DNN_BACKEND_INFERENCE_ENGINE &&
 466          (target == DNN_TARGET_OPENCL_FP16 || target == DNN_TARGET_OPENCL || target == DNN_TARGET_MYRIAD))
 467         throw SkipTestException("");
 468
 469     double l1 = default_l1;
 470     double lInf = default_lInf;
 471     // output range: [-3; 3]
 472     if (backend == DNN_BACKEND_OPENCV && target == DNN_TARGET_OPENCL_FP16) {
 473         l1 = 0.009;
 474         lInf = 0.035;
 475     }
 476     else if (backend == DNN_BACKEND_INFERENCE_ENGINE && target == DNN_TARGET_CPU) {
 477         l1 = 4.6e-5;
 478         lInf = 1.9e-4;
 479     }
 480     testONNXModels("LResNet100E_IR", pb, l1, lInf);
 481 }
 482
 483 TEST_P(Test_ONNX_nets, Emotion_ferplus)
 484 {
 485 #if defined(INF_ENGINE_RELEASE)
 486     if (backend == DNN_BACKEND_INFERENCE_ENGINE && target == DNN_TARGET_MYRIAD
 487             && getInferenceEngineVPUType() == CV_DNN_INFERENCE_ENGINE_VPU_TYPE_MYRIAD_X
 488     )
 489         throw SkipTestException("Test is disabled for MyriadX");
 490 #endif
 491
 492     double l1 = default_l1;
 493     double lInf = default_lInf;
 494
 495     // Output values are in range [-2.011, 2.111]
 496     if (backend == DNN_BACKEND_OPENCV && target == DNN_TARGET_OPENCL_FP16)
 497         l1 = 0.007;
 498     else if (backend == DNN_BACKEND_INFERENCE_ENGINE && target == DNN_TARGET_OPENCL_FP16)
 499     {
 500         l1 = 0.021;
 501         lInf = 0.034;
 502     }
 503     else if (backend == DNN_BACKEND_INFERENCE_ENGINE && (target == DNN_TARGET_CPU || target == DNN_TARGET_OPENCL)) {
 504         l1 = 2.4e-4;
 505         lInf = 6e-4;
 506     }
 507     testONNXModels("emotion_ferplus", pb, l1, lInf);
 508 }
 509
 510 TEST_P(Test_ONNX_nets, Inception_v2)
 511 {
 512     testONNXModels("inception_v2", pb, default_l1, default_lInf, true);
 513 }
 514
 515 TEST_P(Test_ONNX_nets, DenseNet121)
 516 {
 517     applyTestTag(CV_TEST_TAG_MEMORY_512MB);
 518
 519     // output range: [-87; 138], after Softmax [0; 1]
 520     testONNXModels("densenet121", pb, default_l1, default_lInf, true, target != DNN_TARGET_MYRIAD);
 521 }
 522
 523 TEST_P(Test_ONNX_nets, Inception_v1)
 524 {
 525 #if defined(INF_ENGINE_RELEASE)
 526     if (backend == DNN_BACKEND_INFERENCE_ENGINE && target == DNN_TARGET_MYRIAD)
 527         throw SkipTestException("Test is disabled for Myriad targets");
 528 #endif
 529     testONNXModels("inception_v1", pb);
 530 }
 531
 532 TEST_P(Test_ONNX_nets, Shufflenet)
 533 {
 534     if (backend == DNN_BACKEND_INFERENCE_ENGINE &&
 535          (target == DNN_TARGET_OPENCL_FP16 || target == DNN_TARGET_OPENCL || target == DNN_TARGET_MYRIAD))
 536         throw SkipTestException("");
 537     testONNXModels("shufflenet", pb);
 538 }
 539
 540 TEST_P(Test_ONNX_nets, Resnet34_kinetics)
 541 {
 542 #if defined(INF_ENGINE_RELEASE) && INF_ENGINE_VER_MAJOR_LT(2019010000)
 543     throw SkipTestException("Test is enabled starts from 2019R1");
 544 #endif
 545     if (backend != DNN_BACKEND_INFERENCE_ENGINE || target != DNN_TARGET_CPU)
 546         throw SkipTestException("Only DLIE backend on CPU is supported");
 547
 548     String onnxmodel = findDataFile("dnn/resnet-34_kinetics.onnx", false);
 549     Mat image0 = imread(findDataFile("dnn/dog416.png"));
 550     Mat image1 = imread(findDataFile("dnn/street.png"));
 551
 552     Mat ref0 = blobFromNPY(_tf("data/output_kinetics0.npy"));
 553     Mat ref1 = blobFromNPY(_tf("data/output_kinetics1.npy"));
 554
 555     std::vector<Mat> images_0(16, image0);
 556     std::vector<Mat> images_1(16, image1);
 557     Mat blob0 = blobFromImages(images_0, 1.0, Size(112, 112), Scalar(114.7748, 107.7354, 99.4750), true, true);
 558     Mat blob1 = blobFromImages(images_1, 1.0, Size(112, 112), Scalar(114.7748, 107.7354, 99.4750), true, true);
 559
 560     Net permute;
 561     LayerParams lp;
 562     int order[] = {1, 0, 2, 3};
 563     lp.set("order", DictValue::arrayInt<int*>(&order[0], 4));
 564     permute.addLayerToPrev("perm", "Permute", lp);
 565
 566     permute.setInput(blob0);
 567     Mat input0 = permute.forward().clone();
 568
 569     permute.setInput(blob1);
 570     Mat input1 = permute.forward().clone();
 571
 572     int dims[] = {1, 3, 16, 112, 112};
 573     input0 = input0.reshape(0, 5, &dims[0]);
 574     input1 = input1.reshape(0, 5, &dims[0]);
 575
 576     Net net = readNetFromONNX(onnxmodel);
 577     ASSERT_FALSE(net.empty());
 578     net.setPreferableBackend(backend);
 579     net.setPreferableTarget(target);
 580
 581     // output range [-5, 11]
 582     float l1 = 0.0013;
 583     float lInf = 0.009;
 584
 585     checkBackend(&input0, &ref0);
 586     net.setInput(input0);
 587     Mat out = net.forward().clone();
 588     normAssert(ref0, out, "", l1, lInf);
 589
 590     checkBackend(&input1, &ref1);
 591     net.setInput(input1);
 592     out = net.forward().clone();
 593     normAssert(ref1, out, "", l1, lInf);
 594
 595     expectNoFallbacksFromIE(net);
 596 }
 597
 598 INSTANTIATE_TEST_CASE_P(/**/, Test_ONNX_nets, dnnBackendsAndTargets());
 599
 600 }} // namespace