[QNN-EP] Support for Upsample operator

- QNN-EP support for upsample operator
- Add unit test for QNN-EP upsample operator

Author: zhaoxul-qti

onnxruntime/test/providers/qnn/upsample_op_test.cc

@@ -20,16 +20,11 @@ namespace test {
 template <typename DataType>
 static void RunUpsampleTestOnCPU(const TestInputDef<DataType>& input_def,
                                  const TestInputDef<float>& scales_def,
-                                 std::vector<ONNX_NAMESPACE::AttributeProto> attrs,
+                                 std::vector<ONNX_NAMESPACE::AttributeProto>&& attrs,
                                  ExpectedEPNodeAssignment expected_ep_assignment,
                                  int opset = 9) {
   ProviderOptions provider_options;
-
-#if defined(_WIN32)
-  provider_options["backend_path"] = "QnnCpu.dll";
-#else
-  provider_options["backend_path"] = "libQnnCpu.so";
-#endif
+  provider_options["backend_type"] = "cpu";
   provider_options["offload_graph_io_quantization"] = "0";
 
   if (opset <= 7) {
@@ -106,152 +101,14 @@ TEST_F(QnnCPUBackendTests, Upsample_5D) {
                        9);  // Opset
 }
 
-#if defined(__aarch64__) || defined(_M_ARM64) || defined(__linux__)
-//
-// HTP tests:
-//
-
-// Returns a function that creates a graph with a QDQ Upsample operator.
-template <typename QuantType>
-GetTestQDQModelFn<QuantType> BuildQDQUpsampleTestCase(const TestInputDef<float>& input_def,
-                                                      const TestInputDef<int64_t>& scales_def,
-                                                      const std::vector<ONNX_NAMESPACE::AttributeProto>& attrs,
-                                                      int opset = 10,
-                                                      bool use_contrib_qdq = false) {
-  return [input_def, scales_def, attrs,
-          opset, use_contrib_qdq](ModelTestBuilder& builder,
-                                  std::vector<QuantParams<QuantType>>& output_qparams) {
-    // input -> Q -> DQ ->
-    NodeArg* input = MakeTestInput(builder, input_def);
-    QuantParams<QuantType> input_qparams = GetTestInputQuantParams<QuantType>(input_def);
-    NodeArg* input_qdq = AddQDQNodePair<QuantType>(builder, input, input_qparams.scale, input_qparams.zero_point,
-                                                   use_contrib_qdq);
-
-    if (opset <= 7) {
-      // Upsample op
-      NodeArg* upsample_output = builder.MakeIntermediate();
-      Node& upsample_node = builder.AddNode("Upsample", {input_qdq}, {upsample_output});
-    } else {
-      // scales input
-      NodeArg* scales_input = MakeTestInput(builder, scales_def);
-
-      // Upsample op
-      NodeArg* upsample_output = builder.MakeIntermediate();
-      Node& upsample_node = builder.AddNode("Upsample", {input_qdq, scales_input}, {upsample_output});
-    }
-
-    for (auto& attr : attrs) {
-      upsample_node.AddAttributeProto(attr);
-    }
-
-    // op_output -> Q -> DQ -> output
-    // Input and output quantization parameters are equal for Upsample.
-    output_qparams[0] = input_qparams;
-    AddQDQNodePairWithOutputAsGraphOutput<QuantType>(builder, upsample_output, input_qparams.scale,
-                                                     input_qparams.zero_point, use_contrib_qdq);
-  };
-}
-
-// Run a QDQ Upsample model on the QNN HTP EP and the ORT CPU EP. Check the graph node assignment and the QDQ model
-// inference on QNN HTP EP is at least as accurate as on ORT CPU EP (compared to the baseline float32 model).
-template <typename QType>
-static void RunQDQUpsampleTestOnHTP(const TestInputDef<float>& input_def,
-                                    const TestInputDef<float>& scales_def,
-                                    std::vector<ONNX_NAMESPACE::AttributeProto>& attrs,
-                                    ExpectedEPNodeAssignment expected_ep_assignment,
-                                    int opset = 10,
-                                    bool use_contrib_qdq = false) {
-  ProviderOptions provider_options;
-
-#if defined(_WIN32)
-  provider_options["backend_path"] = "QnnHtp.dll";
-#else
-  provider_options["backend_path"] = "libQnnHtp.so";
-#endif
-  provider_options["offload_graph_io_quantization"] = "0";
-
-  if (opset <= 7) {
-    const std::vector<float>& scales = scales_def.GetRawData();
-    attrs.push_back(utils::MakeAttribute("scales", scales));
-
-    auto f32_model_builder = BuildOpTestCase<float>("Upsample", {input_def}, {}, attrs);
-  } else {
-    auto f32_model_builder = BuildOpTestCase<float, float>("Upsample", {input_def}, {scales_def}, attrs);
-  }
-
-  auto qdq_model_builder = BuildQDQUpsampleTestCase<QType>(input_def, scales_def, attrs, opset, use_contrib_qdq);
-
-  TestQDQModelAccuracy(f32_model_builder,
-                       qdq_model_builder,
-                       provider_options,
-                       opset,
-                       expected_ep_assignment);
-}
-
-// Test that QDQ Upsample with a dynamic scales input is not supported by QNN EP.
-TEST_F(QnnHTPBackendTests, Upsample_DynamicScales_Unsupported) {
-  RunQDQUpsampleTestOnHTP<uint8_t>(TestInputDef<float>({1, 3, 4, 4}, false, -10.0f, 10.0f),
-                                   TestInputDef<float>({4}, false /* is_initializer */, {1.0f, 1.0f, 1.5f, 1.5f}),
-                                   {utils::MakeAttribute("mode", "nearest")},  // Attributes
-                                   ExpectedEPNodeAssignment::None,             // Should not be assigned to QNN EP.
-                                   10);                                        // Opset
-}
-
-// Test QDQ Upsample with opset-9, mode `nearest`
-TEST_F(QnnHTPBackendTests, Upsample_4D_Nearest_opset9) {
-  RunQDQUpsampleTestOnHTP<uint8_t>(TestInputDef<float>({1, 3, 4, 4}, false, -10.0f, 10.0f),
-                                   TestInputDef<float>({4}, true, {1.0f, 1.0f, 1.5f, 1.5f}),
-                                   {utils::MakeAttribute("mode", "nearest")},  // Attributes
-                                   ExpectedEPNodeAssignment::All,
-                                   9);  // Opset
-}
-
-// Test QDQ Upsample with opset-9, mode `linear`
-TEST_F(QnnHTPBackendTests, Upsample_4D_Linear_opset9) {
-  RunQDQUpsampleTestOnHTP<uint8_t>(TestInputDef<float>({1, 3, 4, 4}, false, -10.0f, 10.0f),
-                                   TestInputDef<float>({4}, true, {1.0f, 1.0f, 1.5f, 1.5f}),
-                                   {utils::MakeAttribute("mode", "linear")},  // Attributes
-                                   ExpectedEPNodeAssignment::All,
-                                   9);  // Opset
-}
+/*
+QNN HTP backend tests for the QDQ Upsample model is bypassed and can not be enabled.
 
-// Test QDQ Upsample with opset-7, mode `nearest`
-TEST_F(QnnHTPBackendTests, Upsample_4D_Nearest_opset7) {
-  RunQDQUpsampleTestOnHTP<uint8_t>(TestInputDef<float>({1, 3, 4, 4}, false, -10.0f, 10.0f),
-                                   TestInputDef<float>({4}, true, {1.0f, 1.0f, 1.5f, 1.5f}),
-                                   {utils::MakeAttribute("mode", "nearest")},  // Attributes
-                                   ExpectedEPNodeAssignment::All,
-                                   7);  // Opset
-}
-
-// Test QDQ Upsample with opset-7, mode `linear`
-TEST_F(QnnHTPBackendTests, Upsample_4D_Linear_opset7) {
-  RunQDQUpsampleTestOnHTP<uint8_t>(TestInputDef<float>({1, 3, 4, 4}, false, -10.0f, 10.0f),
-                                   TestInputDef<float>({4}, true, {1.0f, 1.0f, 1.5f, 1.5f}),
-                                   {utils::MakeAttribute("mode", "linear")},  // Attributes
-                                   ExpectedEPNodeAssignment::All,
-                                   7);  // Opset
-}
-
-// Test QDQ Upsample 5D
-TEST_F(QnnHTPBackendTests, Upsample_5D) {
-  RunQDQUpsampleTestOnHTP<uint8_t>(TestInputDef<float>({1, 3, 4, 4, 4}, false, -10.0f, 10.0f),
-                                   TestInputDef<float>({5}, true, {1.0f, 1.0f, 1.5f, 1.5f, 1.5f}),
-                                   {utils::MakeAttribute("mode", "nearest")},  // Attributes
-                                   ExpectedEPNodeAssignment::All,
-                                   9);  // Opset
-}
-
-// Test QDQ Upsample 6D not supported for HTP backend
-TEST_F(QnnHTPBackendTests, Upsample_6D) {
-  RunQDQUpsampleTestOnHTP<uint8_t>(TestInputDef<float>({1, 3, 4, 4, 4, 4}, false, -10.0f, 10.0f),
-                                   TestInputDef<float>({6}, true, {1.0f, 1.0f, 1.5f, 1.5f, 1.5f, 1.5f}),
-                                   {utils::MakeAttribute("mode", "nearest")},  // Attributes
-                                   ExpectedEPNodeAssignment::None,
-                                   9);  // Opset
-}
+ONNX Upsample is deprecated in domain version 10. However, ONNX QuantizeLinear and DequantizeLinear are enabled in
+domain version 10. Their conditions are mutually exclusive, so it is not possible for these ops to coexist in the
+same domain version.
+*/
 
-#endif  // defined(__aarch64__) || defined(_M_ARM64) || defined(__linux__)
 }  // namespace test
 }  // namespace onnxruntime
 #endif  // !defined(ORT_MINIMAL_BUILD)