Skip to content

Commit cbb0dc4

Browse files
sgbihusgbihu
committed
change the code based on review inputs
1 parent 56e7162 commit cbb0dc4

File tree

7 files changed

+285
-14
lines changed

7 files changed

+285
-14
lines changed

‎onnxruntime/test/contrib_ops/quantize_ops_test.cc‎

Lines changed: 71 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -287,9 +287,46 @@ TEST(QuantizeLinearContribOpTest, QuantizeLinear_per_tensor_float_int8) {
287287
127, -127,
288288
127, -128,
289289
127, -128});
290+
std::unordered_set<std::string> excluded_providers;
290291
// Disable Tensorrt EP due to error: node1_quantize_scale_node: out of bounds channel axis 1. Number of input dimensions is 1.
291-
test.Run(OpTester::ExpectResult::kExpectSuccess, "", {kTensorrtExecutionProvider});
292+
excluded_providers.insert(kTensorrtExecutionProvider);
293+
// Disable OV EP due to different formulation for QuantizeLinear
294+
excluded_providers.insert(kOpenVINOExecutionProvider);
295+
test.ConfigExcludeEps(excluded_providers)
296+
.RunWithConfig();
297+
}
298+
299+
#ifdef USE_OPENVINO
300+
TEST(QuantizeLinearContribOpTest, OVEPQuantizeLinear_per_tensor_float_int8) {
301+
OpTester test("QuantizeLinear", 1, onnxruntime::kMSDomain);
302+
std::vector<int64_t> dims{16};
303+
test.AddInput<float>("x", dims, {
304+
0.f, 2.f, //
305+
3.f, -3.f, // rounding half to even
306+
2.9f, -2.9f, // low case
307+
3.1f, -3.1f, // up case
308+
254.f, -256.f, // critical point
309+
255.f, -257.f, // critical point
310+
256.f, -258.f, // critical point
311+
1000.f, -1000.f // saturate case
312+
});
313+
test.AddInput<float>("y_scale", {}, {2.0f});
314+
test.AddInput<int8_t>("y_zero_point", {}, {1});
315+
test.AddOutput<int8_t>("y", dims,
316+
{1, 2,
317+
2, 0,
318+
2, 0,
319+
3, -1,
320+
127, -127,
321+
127, -128,
322+
127, -128,
323+
127, -128});
324+
std::vector<std::unique_ptr<IExecutionProvider>> execution_providers;
325+
execution_providers.emplace_back(DefaultOpenVINOExecutionProvider());
326+
test.ConfigEps(std::move(execution_providers))
327+
.RunWithConfig();
292328
}
329+
#endif // USE_OPENVINO
293330

294331
// Test uint16 com.microsoft.QuantizeLinear (per tensor)
295332
TEST(QuantizeLinearContribOpTest, QuantizeLinear_per_tensor_float_uint16) {
@@ -311,10 +348,41 @@ TEST(QuantizeLinearContribOpTest, QuantizeLinear_per_tensor_float_uint16) {
311348
32769, 32765,
312349
65535, 0,
313350
65535, 0});
314-
351+
std::unordered_set<std::string> excluded_providers;
315352
// Disable Tensorrt EP due to error: unsupported data type
316-
test.Run(OpTester::ExpectResult::kExpectSuccess, "", {kTensorrtExecutionProvider});
353+
excluded_providers.insert(kTensorrtExecutionProvider);
354+
// Disable OV EP due to different formulation for QuantizeLinear
355+
excluded_providers.insert(kOpenVINOExecutionProvider);
356+
test.ConfigExcludeEps(excluded_providers)
357+
.RunWithConfig();
358+
}
359+
360+
#ifdef USE_OPENVINO
361+
TEST(QuantizeLinearContribOpTest, OVEPQuantizeLinear_per_tensor_float_uint16) {
362+
OpTester test("QuantizeLinear", 1, onnxruntime::kMSDomain);
363+
std::vector<int64_t> dims{12};
364+
test.AddInput<float>("x", dims, {
365+
0.f, -128.f, 3.f, -3.f, // rounding half to even
366+
2.9f, -2.9f, // round < .5
367+
3.1f, -3.1f, // round > .5
368+
65536.f, -65534.f, // critical point
369+
70000.f, -70000.f // saturate case
370+
});
371+
test.AddInput<float>("scale", {}, {2.0f}, true);
372+
test.AddInput<uint16_t>("zero_point", {}, {32767}, true);
373+
test.AddOutput<uint16_t>("y", dims,
374+
{32767, 32703,
375+
32768, 32766,
376+
32768, 32766,
377+
32769, 32765,
378+
65535, 0,
379+
65535, 0});
380+
std::vector<std::unique_ptr<IExecutionProvider>> execution_providers;
381+
execution_providers.emplace_back(DefaultOpenVINOExecutionProvider());
382+
test.ConfigEps(std::move(execution_providers))
383+
.RunWithConfig();
317384
}
385+
#endif // USE_OPENVINO
318386

319387
// Test int16 com.microsoft.QuantizeLinear (per tensor)
320388
TEST(QuantizeLinearContribOpTest, QuantizeLinear_per_tensor_float_int16) {

‎onnxruntime/test/providers/cpu/controlflow/loop_test.cc‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -828,7 +828,8 @@ TEST(Loop, Opset11WithNoVariadicInputsAndOutputs) {
828828
test.AddOutput<float>("loop_scan_out", {1}, {1.0f});
829829

830830
// Disable TensorRT on unsupported data type BOOL
831-
test.Run(OpTester::ExpectResult::kExpectSuccess, "", {kTensorrtExecutionProvider});
831+
// Disable OpenVino for floating nodes
832+
test.Run(OpTester::ExpectResult::kExpectSuccess, "", {kTensorrtExecutionProvider, kOpenVINOExecutionProvider});
832833
}
833834

834835
// Test a combination of things:

‎onnxruntime/test/providers/cpu/tensor/cast_op_test.cc‎

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -75,6 +75,11 @@ void TestCastOp(gsl::span<const SrcType> input,
7575
excluded_provider_types.insert(kCudaExecutionProvider);
7676
}
7777

78+
if (input.size() == 0) {
79+
// The OpenVINO doesn't support 0 size input
80+
excluded_provider_types.insert(kOpenVINOExecutionProvider);
81+
}
82+
7883
if (cuda_only && (excluded_provider_types.count(kCudaExecutionProvider) > 0)) {
7984
return;
8085
}

‎onnxruntime/test/providers/cpu/tensor/concat_op_test.cc‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -73,6 +73,7 @@ TEST(ConcatOpTest, Concat1D_2) {
7373
test.Run(OpTester::ExpectResult::kExpectSuccess, "",
7474
{kTensorrtExecutionProvider, // TensorRT: no support for dynamic shape tensor
7575
kNnapiExecutionProvider, // NNAPI: concat does not support 0 size input
76+
kOpenVINOExecutionProvider, // OpenVINO: does not support 0 size input
7677
kQnnExecutionProvider}); // QNN: not support dynamic shape tensor
7778
}
7879

@@ -118,6 +119,7 @@ TEST(ConcatOpTest, Concat2D_3) {
118119
test.Run(OpTester::ExpectResult::kExpectSuccess, "",
119120
{kTensorrtExecutionProvider, // TensorRT: no support for dynamic shape tensor
120121
kNnapiExecutionProvider, // NNAPI: concat does not support 0 size input
122+
kOpenVINOExecutionProvider, // OpenVINO: does not support 0 size input
121123
kQnnExecutionProvider}); // QNN: not support dynamic shape tensor
122124
}
123125

‎onnxruntime/test/providers/cpu/tensor/quantize_linear_test.cc‎

Lines changed: 127 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -449,10 +449,43 @@ TEST(QuantizeLinearOpTest, Uint16) {
449449
65535, 0,
450450
65535, 0});
451451

452+
std::unordered_set<std::string> excluded_providers;
452453
// Disable Tensorrt EP due to error: unsupported data type
453-
test.Run(OpTester::ExpectResult::kExpectSuccess, "", {kTensorrtExecutionProvider});
454+
excluded_providers.insert(kTensorrtExecutionProvider);
455+
// Disable OV EP due to different formulation for QuantizeLinear
456+
excluded_providers.insert(kOpenVINOExecutionProvider);
457+
test.ConfigExcludeEps(excluded_providers)
458+
.RunWithConfig();
454459
}
455460

461+
#ifdef USE_OPENVINO
462+
TEST(QuantizeLinearOpTest, OVEP_Uint16) {
463+
OpTester test("QuantizeLinear", 21);
464+
std::vector<int64_t> dims{12};
465+
test.AddInput<float>("x", dims, {
466+
0.f, -128.f, 3.f, -3.f, // rounding half to even
467+
2.9f, -2.9f, // round < .5
468+
3.1f, -3.1f, // round > .5
469+
65536.f, -65534.f, // critical point
470+
70000.f, -70000.f // saturate case
471+
});
472+
test.AddInput<float>("scale", {}, {2.0f}, true);
473+
test.AddInput<uint16_t>("zero_point", {}, {32767}, true);
474+
test.AddOutput<uint16_t>("y", dims,
475+
{32767, 32703,
476+
32768, 32766,
477+
32768, 32766,
478+
32769, 32765,
479+
65535, 0,
480+
65535, 0});
481+
482+
std::vector<std::unique_ptr<IExecutionProvider>> execution_providers;
483+
execution_providers.emplace_back(DefaultOpenVINOExecutionProvider());
484+
test.ConfigEps(std::move(execution_providers))
485+
.RunWithConfig();
486+
}
487+
#endif // USE_OPENVINO
488+
456489
// Test int16 QuantizeLinear (per tensor)
457490
TEST(QuantizeLinearOpTest, Int16) {
458491
OpTester test("QuantizeLinear", 21);
@@ -502,8 +535,40 @@ TEST(QuantizeLinearOpTest, Int4) {
502535
{Int4x2(-8, -7), Int4x2(-1, 1), Int4x2(2, 7),
503536
Int4x2(7, unused_val)});
504537

505-
test.Run(OpTester::ExpectResult::kExpectSuccess, "", {kTensorrtExecutionProvider});
538+
std::unordered_set<std::string> excluded_providers;
539+
excluded_providers.insert(kTensorrtExecutionProvider);
540+
// Disable OV EP due to different formulation for QuantizeLinear
541+
excluded_providers.insert(kOpenVINOExecutionProvider);
542+
test.ConfigExcludeEps(excluded_providers)
543+
.RunWithConfig();
544+
}
545+
546+
#ifdef USE_OPENVINO
547+
TEST(QuantizeLinearOpTest, OVEP_Int4) {
548+
OpTester test("QuantizeLinear", 21);
549+
std::vector<int64_t> dims{7};
550+
constexpr int8_t unused_val = 0;
551+
test.AddInput<float>("x", dims, {
552+
-20.0f, // Clamp to qmin
553+
-16.0f, // Close to qmin
554+
-3.0f, // round
555+
0.0f, // Zero-point
556+
2.9f, // round
557+
12.0f, // qmax
558+
20.0f, // Clamp to qmax
559+
});
560+
test.AddInput<float>("scale", {}, {2.0f}, true);
561+
test.AddInput<Int4x2>("zero_point", {}, {Int4x2(1, unused_val)}, true);
562+
test.AddOutput<Int4x2>("y", dims,
563+
{Int4x2(-8, -7), Int4x2(0, 1), Int4x2(2, 7),
564+
Int4x2(7, unused_val)});
565+
566+
std::vector<std::unique_ptr<IExecutionProvider>> execution_providers;
567+
execution_providers.emplace_back(DefaultOpenVINOExecutionProvider());
568+
test.ConfigEps(std::move(execution_providers))
569+
.RunWithConfig();
506570
}
571+
#endif // USE_OPENVINO
507572

508573
// Test uint4 QuantizeLinear (per tensor)
509574
TEST(QuantizeLinearOpTest, UInt4) {
@@ -569,7 +634,12 @@ TEST(QuantizeLinearOpTest, OddLarge_Int4) {
569634
test.AddInput<Int4x2>("zero_point", {}, {Int4x2(zp, unused_val)}, true);
570635
test.AddOutput<Int4x2>("y", dims, output);
571636

572-
test.Run(OpTester::ExpectResult::kExpectSuccess, "", {kTensorrtExecutionProvider});
637+
std::unordered_set<std::string> excluded_providers;
638+
excluded_providers.insert(kTensorrtExecutionProvider);
639+
// Disable OV EP due to different formulation for QuantizeLinear
640+
excluded_providers.insert(kOpenVINOExecutionProvider);
641+
test.ConfigExcludeEps(excluded_providers)
642+
.RunWithConfig();
573643
}
574644

575645
// Test uint4 QuantizeLinear (per tensor) with a "large" and odd number of input elements.
@@ -595,7 +665,12 @@ TEST(QuantizeLinearOpTest, OddLarge_UInt4) {
595665
test.AddInput<UInt4x2>("zero_point", {}, {UInt4x2(zp, unused_val)}, true);
596666
test.AddOutput<UInt4x2>("y", dims, output);
597667

598-
test.Run(OpTester::ExpectResult::kExpectSuccess, "", {kTensorrtExecutionProvider});
668+
std::unordered_set<std::string> excluded_providers;
669+
excluded_providers.insert(kTensorrtExecutionProvider);
670+
// Disable OV EP due to different formulation for QuantizeLinear
671+
excluded_providers.insert(kOpenVINOExecutionProvider);
672+
test.ConfigExcludeEps(excluded_providers)
673+
.RunWithConfig();
599674
}
600675

601676
// quantize with scalar zero point and scale
@@ -611,10 +686,31 @@ TEST(QuantizeLinearOpTest, Int8_NegativeZeroPoint) {
611686
test.AddInput<float>("y_scale", {}, {.039215686f});
612687
test.AddInput<int8_t>("y_zero_point", {}, {-23});
613688
test.AddOutput<int8_t>("y", dims, {-23, 28, 53, 104, 127, -74, -128, -128});
689+
std::unordered_set<std::string> excluded_providers;
614690
// Disable Tensorrt EP due to the error, node1_quantize_scale_node: out of bounds channel axis 1. Number of input dimensions is 1.
615-
test.Run(OpTester::ExpectResult::kExpectSuccess, "", {kTensorrtExecutionProvider});
691+
excluded_providers.insert(kTensorrtExecutionProvider);
692+
// Disable OV EP due to different formulation for QuantizeLinear
693+
excluded_providers.insert(kOpenVINOExecutionProvider);
694+
test.ConfigExcludeEps(excluded_providers)
695+
.RunWithConfig();
616696
}
617697

698+
#ifdef USE_OPENVINO
699+
TEST(QuantizeLinearOpTest, OVEP_Int8_NegativeZeroPoint) {
700+
701+
OpTester test("QuantizeLinear", 10);
702+
std::vector<int64_t> dims{8};
703+
test.AddInput<float>("x", dims, {0, 2, 3, 5, 6, -2, -5, -6});
704+
test.AddInput<float>("y_scale", {}, {.039215686f});
705+
test.AddInput<int8_t>("y_zero_point", {}, {-23});
706+
test.AddOutput<int8_t>("y", dims, {-23, 28, 54, 105, 127, -74, -128, -128});
707+
std::vector<std::unique_ptr<IExecutionProvider>> execution_providers;
708+
execution_providers.emplace_back(DefaultOpenVINOExecutionProvider());
709+
test.ConfigEps(std::move(execution_providers))
710+
.RunWithConfig();
711+
}
712+
#endif // USE_OPENVINO
713+
618714
// quantize with scalar zero point and scale
619715
TEST(QuantizeLinearOpTest, Int8_PositiveZeroPoint) {
620716
// TODO: Unskip when fixed #41968513
@@ -628,9 +724,34 @@ TEST(QuantizeLinearOpTest, Int8_PositiveZeroPoint) {
628724
test.AddInput<float>("y_scale", {}, {.039215686f});
629725
test.AddInput<int8_t>("y_zero_point", {}, {23});
630726
test.AddOutput<int8_t>("y", dims, {23, 74, 99, 127, 127, -28, -104, -128});
727+
std::unordered_set<std::string> excluded_providers;
631728
// Disable Tensorrt EP due to error:node1_quantize_scale_node: out of bounds channel axis 1. Number of input dimensions is 1.
632-
test.Run(OpTester::ExpectResult::kExpectSuccess, "", {kTensorrtExecutionProvider});
729+
excluded_providers.insert(kTensorrtExecutionProvider);
730+
// Disable OV EP due to different formulation for QuantizeLinear
731+
excluded_providers.insert(kOpenVINOExecutionProvider);
732+
test.ConfigExcludeEps(excluded_providers)
733+
.RunWithConfig();
734+
}
735+
736+
#ifdef USE_OPENVINO
737+
TEST(QuantizeLinearOpTest, OVEP_Int8_PositiveZeroPoint) {
738+
// TODO: Unskip when fixed #41968513
739+
if (DefaultDmlExecutionProvider().get() != nullptr) {
740+
GTEST_SKIP() << "Skipping because of the following error: Expected equality of these values: -104 and -105";
741+
}
742+
743+
OpTester test("QuantizeLinear", 10);
744+
std::vector<int64_t> dims{8};
745+
test.AddInput<float>("x", dims, {0, 2, 3, 5, 6, -2, -5, -6});
746+
test.AddInput<float>("y_scale", {}, {.039215686f});
747+
test.AddInput<int8_t>("y_zero_point", {}, {23});
748+
test.AddOutput<int8_t>("y", dims, {23, 74, 100, 127, 127, -28, -104, -128});
749+
std::vector<std::unique_ptr<IExecutionProvider>> execution_providers;
750+
execution_providers.emplace_back(DefaultOpenVINOExecutionProvider());
751+
test.ConfigEps(std::move(execution_providers))
752+
.RunWithConfig();
633753
}
754+
#endif // USE_OPENVINO
634755

635756
// quantize with 2D data
636757
TEST(QuantizeLinearOpTest, 2D) {

0 commit comments

Comments
 (0)