[WebNN] Remove NHWC preferred layout (microsoft#25679)

Chromium has implemented constant folding for transpose which eliminates
the performance penalty introduced by additional transpose ops for
context with NHWC preferred layout.

Chromium CL:
https://chromium-review.googlesource.com/c/chromium/src/+/6774969

Now we can safety remove the NHWC optimization in WebNN EP.

Author: Honry

onnxruntime/core/providers/webnn/builders/helper.h

@@ -38,19 +38,6 @@ WebnnDeviceType DeviceTypeFromString(const std::string_view& device_type);
 // Collects all the initializer tensors in the subGraph and its ancestor graphs.
 InitializedTensorSet CollectAllInitializedTensors(const GraphViewer& graph_viewer);
 
-inline std::vector<int64_t> convertAxesFromNCHWtoNHWC(const std::vector<int64_t>& axes) {
-  constexpr std::array<int64_t, 4> nchw_to_nhwc = {0, 3, 1, 2};
-  std::vector<int64_t> new_axes;
-  new_axes.reserve(axes.size());
-  for (int64_t axis : axes) {
-    if (axis >= nchw_to_nhwc.size()) {
-      ORT_THROW("Invalid axis value: ", axis);
-    }
-    new_axes.push_back(nchw_to_nhwc[static_cast<size_t>(axis)]);
-  }
-  return new_axes;
-}
-
 inline std::vector<int64_t> HandleNegativeAxes(const std::vector<int64_t>& axes, size_t input_size) {
   std::vector<int64_t> new_axes(axes.size());
   for (size_t i = 0; i < axes.size(); ++i) {

onnxruntime/core/providers/webnn/builders/impl/builder_utils.cc

@@ -18,10 +18,9 @@ common::Status ComputeConvPads(const std::vector<int64_t> input_shape,
                                const std::vector<int64_t>& onnx_strides,
                                const std::vector<int64_t>& onnx_dilations,
                                AutoPadType auto_pad_type,
-                               std::vector<int64_t>& pads_out,
-                               bool use_nchw) {
-  const int64_t input_size_y = use_nchw ? input_shape[2] : input_shape[1];
-  const int64_t input_size_x = use_nchw ? input_shape[3] : input_shape[2];
+                               std::vector<int64_t>& pads_out) {
+  const int64_t input_size_y = input_shape[2];
+  const int64_t input_size_x = input_shape[3];
   const int64_t stride_y = onnx_strides[0];
   const int64_t stride_x = onnx_strides[1];
   const int64_t dilation_y = onnx_dilations[0];
@@ -53,17 +52,12 @@ common::Status HandleAutoPad(const std::vector<int64_t> input_shape,
                              const std::vector<int64_t>& onnx_strides,
                              const std::vector<int64_t>& onnx_dilations,
                              AutoPadType auto_pad_type,
-                             std::vector<int64_t>& pads_out,
-                             bool use_nchw) {
-  if (AutoPadType::SAME_UPPER == auto_pad_type) {
-    ORT_RETURN_IF_ERROR(ComputeConvPads(input_shape, weight_size_y, weight_size_x,
-                                        onnx_pads, onnx_strides, onnx_dilations,
-                                        AutoPadType::SAME_UPPER, pads_out, use_nchw));
-  } else {
-    ORT_RETURN_IF_ERROR(ComputeConvPads(input_shape, weight_size_y, weight_size_x,
-                                        onnx_pads, onnx_strides, onnx_dilations,
-                                        AutoPadType::SAME_LOWER, pads_out, use_nchw));
-  }
+                             std::vector<int64_t>& pads_out) {
+  AutoPadType pad_type = (AutoPadType::SAME_UPPER == auto_pad_type) ? AutoPadType::SAME_UPPER : AutoPadType::SAME_LOWER;
+
+  ORT_RETURN_IF_ERROR(ComputeConvPads(input_shape, weight_size_y, weight_size_x,
+                                      onnx_pads, onnx_strides, onnx_dilations,
+                                      pad_type, pads_out));
   return Status::OK();
 }
 
@@ -110,10 +104,9 @@ common::Status ComputeConvTransposePadsAndOutputShape(const std::vector<int64_t>
                                                       const std::vector<int64_t>& onnx_output_padding,
                                                       AutoPadType auto_pad_type,
                                                       std::vector<int64_t>& pads_out,
-                                                      std::vector<int64_t>& output_shape_out,
-                                                      bool use_nchw) {
-  const int64_t input_size_y = use_nchw ? input_shape[2] : input_shape[1];
-  const int64_t input_size_x = use_nchw ? input_shape[3] : input_shape[2];
+                                                      std::vector<int64_t>& output_shape_out) {
+  const int64_t input_size_y = input_shape[2];
+  const int64_t input_size_x = input_shape[3];
   const int64_t stride_y = onnx_strides[0];
   const int64_t stride_x = onnx_strides[1];
   const int64_t dilation_y = onnx_dilations[0];

onnxruntime/core/providers/webnn/builders/impl/builder_utils.h

@@ -21,8 +21,7 @@ common::Status HandleAutoPad(const std::vector<int64_t> input_shape,
                              const std::vector<int64_t>& onnx_strides,
                              const std::vector<int64_t>& onnx_dilations,
                              AutoPadType auto_pad_type,
-                             std::vector<int64_t>& pads_out,
-                             bool use_nchw) ORT_MUST_USE_RESULT;
+                             std::vector<int64_t>& pads_out) ORT_MUST_USE_RESULT;
 
 // Compute pads and output shape for ConvTranspose.
 common::Status ComputeConvTransposePadsAndOutputShape(const std::vector<int64_t> input_shape,
@@ -34,8 +33,7 @@ common::Status ComputeConvTransposePadsAndOutputShape(const std::vector<int64_t>
                                                       const std::vector<int64_t>& onnx_output_padding,
                                                       AutoPadType auto_pad_type,
                                                       std::vector<int64_t>& pads_out,
-                                                      std::vector<int64_t>& output_shape_out,
-                                                      bool use_nchw) ORT_MUST_USE_RESULT;
+                                                      std::vector<int64_t>& output_shape_out) ORT_MUST_USE_RESULT;
 
 }  // namespace webnn
 }  // namespace onnxruntime

onnxruntime/core/providers/webnn/builders/impl/conv_op_builder.cc

@@ -17,9 +17,6 @@ namespace webnn {
 
 class ConvOpBuilder : public BaseOpBuilder {
   // Add operator related.
- public:
-  void AddInitializersToSkip(ModelBuilder& model_builder, const Node& node) const override;
-
  private:
   Status AddToModelBuilderImpl(ModelBuilder& model_builder, const Node& node,
                                const logging::Logger& logger) const override ORT_MUST_USE_RESULT;
@@ -34,13 +31,6 @@ class ConvOpBuilder : public BaseOpBuilder {
                                const logging::Logger& logger) const override;
 };
 
-void ConvOpBuilder::AddInitializersToSkip(ModelBuilder& model_builder, const Node& node) const {
-  // skip the weight for conv as we need to transpose for preferred layout NHWC.
-  if (model_builder.GetPreferredLayout() == DataLayout::NHWC) {
-    model_builder.AddInitializerToSkip(node.InputDefs()[1]->Name());  // W
-  }
-}
-
 // Helper functions
 common::Status SetConvBaseOptions(ModelBuilder& model_builder,
                                   const Node& node, emscripten::val& options,
@@ -49,7 +39,6 @@ common::Status SetConvBaseOptions(ModelBuilder& model_builder,
                                   const std::vector<int64_t>& strides,
                                   const std::vector<int64_t>& dilations,
                                   std::vector<int64_t>& pads,
-                                  const bool is_nhwc,
                                   const bool is_conv1d,
                                   const logging::Logger& logger) {
   NodeAttrHelper helper(node);
@@ -63,7 +52,7 @@ common::Status SetConvBaseOptions(ModelBuilder& model_builder,
     // Calculate explicit padding for autoPad.
     if (AutoPadType::SAME_UPPER == auto_pad_type || AutoPadType::SAME_LOWER == auto_pad_type) {
       ORT_RETURN_IF_ERROR(HandleAutoPad(input_shape, weight_shape[2], weight_shape[3],
-                                        pads, strides, dilations, auto_pad_type, pads_out, !is_nhwc));
+                                        pads, strides, dilations, auto_pad_type, pads_out));
       pads = pads_out;
     }
   } else if (op_type == "ConvTranspose") {
@@ -84,7 +73,7 @@ common::Status SetConvBaseOptions(ModelBuilder& model_builder,
     // Otherwise compute the output shape, as well as the pads if the auto_pad attribute is SAME_UPPER/SAME_LOWER.
     ORT_RETURN_IF_ERROR(ComputeConvTransposePadsAndOutputShape(input_shape, weight_shape[2], weight_shape[3],
                                                                pads, strides, dilations, output_padding,
-                                                               auto_pad_type, pads_out, output_shape, !is_nhwc));
+                                                               auto_pad_type, pads_out, output_shape));
 
     if (output_shape[0] != -1 && output_shape[1] != -1) {
       options.set("outputSizes", emscripten::val::array(GetNarrowedIntFromInt64<uint32_t>(output_shape)));
@@ -113,90 +102,6 @@ common::Status SetConvBaseOptions(ModelBuilder& model_builder,
   return Status::OK();
 }
 
-// Both depthwise Conv and ConvTranspose share the same logic to add the layout.
-Status AddInitializerInNewLayout(ModelBuilder& model_builder,
-                                 const std::string& name,
-                                 bool is_conv,
-                                 bool is_conv1d) {
-  const auto& tensor = *model_builder.GetInitializerTensors().at(name);
-  auto data_type = tensor.data_type();
-
-  const auto& shape = tensor.dims();
-  std::vector<uint32_t> dims =
-      GetNarrowedIntFromInt64<uint32_t>(std::vector<int64_t>(std::begin(shape), std::end(shape)));
-
-  if (is_conv1d) {
-    // Support conv1d by prepending a 1 size dimension.
-    dims.push_back(1);
-  }
-
-  const uint8_t* src = nullptr;
-  Initializer unpacked_tensor(tensor, model_builder.GetGraphViewer().ModelPath());
-  src = unpacked_tensor.DataAsByteSpan().data();
-  const auto out_t = dims[0], in_t = dims[1],
-             h_t = dims[2], w_t = dims[3];
-  std::vector<uint32_t> dest_shape;
-  if (is_conv)
-    dest_shape = {out_t, h_t, w_t, in_t};  // L_0231
-  else
-    dest_shape = {in_t, h_t, w_t, out_t};  // L_1230 for depthwise conv and convTranspose weight
-
-  SafeInt<size_t> num_elements = SafeInt<size_t>(Product(dest_shape));
-
-  size_t element_size{0};
-  switch (data_type) {
-    case ONNX_NAMESPACE::TensorProto_DataType_UINT8:
-      element_size = sizeof(uint8_t);
-      break;
-    case ONNX_NAMESPACE::TensorProto_DataType_INT8:
-      element_size = sizeof(int8_t);
-      break;
-    case ONNX_NAMESPACE::TensorProto_DataType_FLOAT16:
-      element_size = sizeof(uint16_t);
-      break;
-    case ONNX_NAMESPACE::TensorProto_DataType_FLOAT:
-      element_size = sizeof(float);
-      break;
-    default:
-      break;
-  }
-  std::unique_ptr<uint8_t[]> buffer_holder(new uint8_t[element_size * num_elements]);
-  uint8_t* buffer = buffer_holder.get();
-
-  for (uint32_t out = 0; out < out_t; out++) {
-    for (uint32_t in = 0; in < in_t; in++) {
-      for (uint32_t h = 0; h < h_t; h++) {
-        for (uint32_t w = 0; w < w_t; w++) {
-          auto onnx_idx = out * in_t * h_t * w_t +
-                          in * h_t * w_t +
-                          h * w_t +
-                          w;
-
-          uint32_t wnn_idx;
-          if (is_conv == 1) {  // L_0231
-            wnn_idx = out * h_t * w_t * in_t +
-                      h * w_t * in_t +
-                      w * in_t +
-                      in;
-          } else {  // L_1230 for depthwise conv weight
-            wnn_idx = in * h_t * w_t * out_t +
-                      h * w_t * out_t +
-                      w * out_t +
-                      out;
-          }
-
-          for (size_t i = 0; i < element_size; i++) {
-            buffer[element_size * wnn_idx + i] = src[element_size * onnx_idx + i];
-          }
-        }
-      }
-    }
-  }
-  ORT_RETURN_IF_ERROR(model_builder.AddOperandFromPersistMemoryBuffer(name, buffer, num_elements * element_size,
-                                                                      dest_shape, data_type));
-  return Status::OK();
-}
-
 // Add operator related.
 
 Status ConvOpBuilder::AddToModelBuilderImpl(ModelBuilder& model_builder, const Node& node,
@@ -213,31 +118,25 @@ Status ConvOpBuilder::AddToModelBuilderImpl(ModelBuilder& model_builder, const N
   std::vector<int64_t> weight_shape;
   ORT_RETURN_IF_NOT(GetShape(*input_defs[1], weight_shape, logger), "Cannot get weight shape");
   const auto& weight_name = input_defs[1]->Name();
+  emscripten::val filter = model_builder.GetOperand(weight_name);
 
   NodeAttrHelper helper(node);
   auto strides = helper.Get("strides", std::vector<int64_t>{1, 1});
   auto dilations = helper.Get("dilations", std::vector<int64_t>{1, 1});
   auto pads = helper.Get("pads", std::vector<int64_t>{0, 0, 0, 0});
 
-  const bool is_nhwc = model_builder.GetPreferredLayout() == DataLayout::NHWC;
   const bool is_conv1d = input_shape.size() == 3 && weight_shape.size() == 3;
-  const bool is_constant_weight = Contains(initializers, weight_name);
 
   emscripten::val common_options = emscripten::val::object();
   // Support conv1d by prepending a 1 or 2 size dimensions.
   if (is_conv1d) {
     // Reshape input.
-    if (is_nhwc) {
-      // For NHWC preferred layout, the input has been transposed.
-      // For conv1d it is NCD1 -> ND1C, so we need to prepend 1 to the index 2.
-      input_shape.insert(input_shape.begin() + 2, 1);
-    } else {
-      input_shape.push_back(1);
-    }
-    std::vector<uint32_t> new_shape = GetNarrowedIntFromInt64<uint32_t>(input_shape);
+    input_shape.push_back(1);
+    std::vector<uint32_t> new_input_shape = GetNarrowedIntFromInt64<uint32_t>(input_shape);
     common_options.set("label", node.Name() + "_reshape_input");
     input = model_builder.GetBuilder().call<emscripten::val>("reshape", input,
-                                                             emscripten::val::array(new_shape), common_options);
+                                                             emscripten::val::array(new_input_shape),
+                                                             common_options);
 
     weight_shape.resize(4, 1);  // Ensure 4D by appending 1's if needed.
     strides.resize(2, 1);       // Ensure 2D by appending 1's if needed.
@@ -246,68 +145,21 @@ Status ConvOpBuilder::AddToModelBuilderImpl(ModelBuilder& model_builder, const N
       pads.insert(pads.begin() + 1, 0);
       pads.push_back(0);
     }
+
+    // Reshape weight to 4D for conv1d.
+    // The weight_shape has been appended 1's, reshape weight operand.
+    std::vector<uint32_t> new_weight_shape = GetNarrowedIntFromInt64<uint32_t>(weight_shape);
+    common_options.set("label", node.Name() + "_reshape_filter");
+    filter = model_builder.GetBuilder().call<emscripten::val>("reshape",
+                                                              filter,
+                                                              emscripten::val::array(new_weight_shape),
+                                                              common_options);
   }
 
   emscripten::val options = emscripten::val::object();
   options.set("label", node.Name());
   ORT_RETURN_IF_ERROR(SetConvBaseOptions(
-      model_builder, node, options, input_shape, weight_shape, strides, dilations, pads, is_nhwc, is_conv1d, logger));
-  bool depthwise = false;
-  if (op_type == "Conv" || op_type == "ConvInteger") {
-    int groups = options["groups"].as<int>();
-    if (is_nhwc) {
-      depthwise = (groups == input_shape[3] && groups != 1);
-      options.set("inputLayout", emscripten::val("nhwc"));
-      if (is_constant_weight) {
-        ORT_RETURN_IF_ERROR(AddInitializerInNewLayout(model_builder, weight_name, !depthwise, is_conv1d));
-      }
-      if (!depthwise) {
-        options.set("filterLayout", emscripten::val("ohwi"));
-      } else {
-        options.set("filterLayout", emscripten::val("ihwo"));
-      }
-    }
-  } else {  // ConvTranspose
-    if (is_nhwc) {
-      options.set("inputLayout", emscripten::val("nhwc"));
-      options.set("filterLayout", emscripten::val("ohwi"));
-      if (is_constant_weight) {
-        ORT_RETURN_IF_ERROR(AddInitializerInNewLayout(model_builder, weight_name, false, is_conv1d));
-      }
-    }
-  }
-
-  emscripten::val filter = model_builder.GetOperand(weight_name);
-
-  if (is_conv1d) {
-    // Reshape weight to 4D for conv1d.
-    if (!is_nhwc || !is_constant_weight) {
-      // The weight_shape has been appended 1's, reshape weight operand.
-      std::vector<uint32_t> new_shape = GetNarrowedIntFromInt64<uint32_t>(weight_shape);
-      common_options.set("label", node.Name() + "_reshape_filter");
-      filter = model_builder.GetBuilder().call<emscripten::val>("reshape",
-                                                                filter,
-                                                                emscripten::val::array(new_shape),
-                                                                common_options);
-    }
-  }
-
-  if (is_nhwc && !is_constant_weight) {
-    // For NHWC preferred layout, if the weight is input:
-    // - Transpose it from iohw -> ohwi for convTranspose.
-    // - Transpose it from oihw -> ihwo for depthwise conv.
-    // - Transpose it from oihw -> ohwi for conv.
-    std::vector<uint32_t> perm(4);
-    if (op_type == "ConvTranspose" || depthwise) {
-      perm = {1, 2, 3, 0};  // L_1230 for depthwise conv and convTranspose weight
-    } else {
-      perm = {0, 2, 3, 1};  // L_0231
-    }
-    emscripten::val transpose_options = emscripten::val::object();
-    transpose_options.set("permutation", emscripten::val::array(perm));
-    transpose_options.set("label", node.Name() + "_transpose_filter");
-    filter = model_builder.GetBuilder().call<emscripten::val>("transpose", filter, transpose_options);
-  }
+      model_builder, node, options, input_shape, weight_shape, strides, dilations, pads, is_conv1d, logger));
 
   if (op_type == "Conv") {
     output = model_builder.GetBuilder().call<emscripten::val>("conv2d", input, filter, options);