saymrwulf/onnxruntime
1
0
Fork 0
mirror of https://github.com/saymrwulf/onnxruntime.git synced 2026-07-30 20:18:08 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

[WebNN EP] Use GetVecUint32FromVecInt64 to simplify the code (#19324)

Browse source 
- Use the function `GetVecUint32FromVecInt64` in helper.h to replace
`transform`.
- Change some `int32_t` to `uint32_t`.
- Remove a useless `temp`.
This commit is contained in:
zesongw 2024-01-31 16:20:07 +08:00 committed by GitHub
parent 3262e8df2f
commit d87f73ab44
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
6 changed files with 7 additions and 23 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
onnxruntime/core/providers/webnn/builders/impl/normalization_op_builder.cc
View file

@ -125,10 +125,7 @@ Status NormalizationOpBuilder::AddToModelBuilderImpl(ModelBuilder& model_builder
output = model_builder.GetBuilder().call<emscripten::val>("instanceNormalization", input, options);
// Reshape back to the original output shape for 3D input.
if (input_shape.size() != 4) {
std::vector<uint32_t> output_shape;
std::transform(input_shape.begin(), input_shape.end(),
std::back_inserter(output_shape),
[](int64_t dim) -> uint32_t { return SafeInt<uint32_t>(dim); });
std::vector<uint32_t> output_shape = GetVecUint32FromVecInt64(input_shape);
output = model_builder.GetBuilder().call<emscripten::val>(
"reshape", output, emscripten::val::array(output_shape));
}

7
onnxruntime/core/providers/webnn/builders/impl/pool_op_builder.cc
View file

@ -81,7 +81,7 @@ Status PoolOpBuilder::AddToModelBuilderImpl(ModelBuilder& model_builder,
const auto onnx_kernel_shape = helper.Get("kernel_shape", std::vector<int64_t>{0, 0});
const auto onnx_strides = helper.Get("strides", std::vector<int64_t>{1, 1});
const auto onnx_pads = helper.Get("pads", std::vector<int64_t>{0, 0, 0, 0});
auto pads = helper.Get("pads", std::vector<int32_t>{0, 0, 0, 0});
auto pads = helper.Get("pads", std::vector<uint32_t>{0, 0, 0, 0});
std::vector<int64_t> input_shape;
ORT_RETURN_IF_NOT(GetShape(*input_defs[0], input_shape, logger), "Cannot get shape");
AutoPadType auto_pad_type = StringToAutoPadType(helper.Get("auto_pad", "NOTSET"));
@ -94,12 +94,11 @@ Status PoolOpBuilder::AddToModelBuilderImpl(ModelBuilder& model_builder,
auto_pad_type,
pads_out,
model_builder.GetPreferredLayout() == DataLayout::NCHW));
std::transform(pads_out.begin(), pads_out.end(), pads.begin(),
[](int64_t pad) -> int32_t { return static_cast<int32_t>(pad); });
pads = GetVecUint32FromVecInt64(pads_out);
}
// Permute the ONNX's pads, which is [beginning_height, beginning_width, ending_height, ending_width],
// while WebNN's padding is [beginning_height, ending_height, beginning_width, ending_width].
const std::vector<int32_t> padding{pads[0], pads[2], pads[1], pads[3]};
const std::vector<uint32_t> padding{pads[0], pads[2], pads[1], pads[3]};
options.set("padding", emscripten::val::array(padding));
const auto ceil_mode = helper.Get("ceil_mode", 0);

5
onnxruntime/core/providers/webnn/builders/impl/split_op_builder.cc
View file

@ -83,10 +83,7 @@ Status SplitOpBuilder::AddToModelBuilderImpl(ModelBuilder& model_builder,
std::vector<int64_t> mapping_split;
mapping_split.insert(mapping_split.begin(), num_outputs - 1, input_shape[axis] / num_outputs);
mapping_split.insert(mapping_split.end(), input_shape[axis] % num_outputs);
std::vector<int32_t> converted_splits;
std::transform(mapping_split.cbegin(), mapping_split.cend(),
std::back_inserter(converted_splits),
[](int64_t dim) -> int32_t { return SafeInt<int32_t>(dim); });
std::vector<uint32_t> converted_splits = GetVecUint32FromVecInt64(mapping_split);
output_array = model_builder.GetBuilder().call<emscripten::val>("split",
input,
emscripten::val::array(converted_splits),

5
onnxruntime/core/providers/webnn/builders/impl/squeeze_unsqueeze_op_builder.cc
View file

@ -87,10 +87,7 @@ Status SqueezeUnsqueezeOpBuilder::AddToModelBuilderImpl(ModelBuilder& model_buil
emscripten::val output = emscripten::val::undefined();
// Use WebNN's reshape to implement Squeeze/Unsqueeze.
std::vector<uint32_t> new_shape;
std::transform(
input_shape.begin(), input_shape.end(), std::back_inserter(new_shape),
[](int64_t data) -> uint32_t { return SafeInt<uint32_t>(data); });
std::vector<uint32_t> new_shape = GetVecUint32FromVecInt64(input_shape);
// Sort axes_data in ascending order.
std::sort(axes_data.begin(), axes_data.end());
if (op_type == "Squeeze") {

5
onnxruntime/core/providers/webnn/builders/impl/transpose_op_builder.cc
View file

@ -40,10 +40,7 @@ Status TransposeOpBuilder::AddToModelBuilderImpl(ModelBuilder& model_builder,
emscripten::val input = model_builder.GetOperand(input_defs[0]->Name());
emscripten::val options = emscripten::val::object();
std::vector<int32_t> permutation;
std::transform(perm.cbegin(), perm.cend(),
std::back_inserter(permutation),
[](int64_t dim) -> int32_t { return SafeInt<int32_t>(dim); });
std::vector<uint32_t> permutation = GetVecUint32FromVecInt64(perm);
options.set("permutation", emscripten::val::array(permutation));
emscripten::val output = model_builder.GetBuilder().call<emscripten::val>("transpose", input, options);
model_builder.AddOperand(node.OutputDefs()[0]->Name(), std::move(output));

3
onnxruntime/core/providers/webnn/webnn_execution_provider.cc
View file

@ -282,9 +282,6 @@ common::Status WebNNExecutionProvider::Compile(const std::vector<FusedNodeAndGra
// Since all the input output of WebNN EP is MultiArray, we will make the scalar input as a {1} MultiArray.
if (shape.empty())
shape.push_back(1);
std::vector<int> temp(shape.size());
transform(shape.begin(), shape.end(), temp.begin(),
[](int64_t dim) -> uint32_t { return SafeInt<int32_t>(dim); });
const void* inputBuffer = const_cast<void*>(input_tensor.GetTensorRawData());
inputs.emplace(
input_name,