Skip to content

N
ngraph
Unverified Commit 2dc0c48f authored by Adam Procter's avatar Adam Procter Committed by GitHub
Browse files
Options

Merge branch 'master' into krovatkin/rs_slice_heuristic

parents c249c289 2f180f90
Hide whitespace changes
Inline Side-by-side
Showing with 154 additions and 142 deletions
python/ngraph/__init__.py
View file @ 2dc0c48f
......@@ -15,8 +15,12 @@
# ******************************************************************************
"""ngraph module namespace, exposing factory functions for all ops and other classes."""
from pkg_resources import get_distribution
__version__ = get_distribution('ngraph-core').version
from pkg_resources import get_distribution, DistributionNotFound
try:
__version__ = get_distribution('ngraph-core').version
except DistributionNotFound:
__version__ = '0.0.0-dev'
from ngraph.ops import absolute
from ngraph.ops import absolute as abs
......
src/ngraph/pass/memory_layout.cpp
View file @ 2dc0c48f
......@@ -68,9 +68,13 @@ bool pass::MemoryLayout::run_on_function(shared_ptr<ngraph::Function> function)
// Non-destructive kernels can pass through if memory sharing is disabled
if ((node->liveness_free_list.count(input) != 0 ||
std::dynamic_pointer_cast<op::GetOutputElement>(node) ||
(m_disable_memory_sharing && !oi_pair.destructive)) &&
(m_disable_memory_sharing && !oi_pair.destructive &&
!input_node->is_parameter() && !input_node->is_constant())) &&
node->liveness_new_list.count(output) != 0)
{
NGRAPH_DEBUG << "Reusing " << input->get_name() << " for "
<< output->get_name();
in_place_outputs.insert({output, input});
reused_inputs.insert(input);
}
......
test/CMakeLists.txt
View file @ 2dc0c48f
......@@ -65,13 +65,6 @@ set(SRC
set_source_files_properties(includes.cpp PROPERTIES COMPILE_DEFINITIONS
NGRAPH_INCLUDES="${PROJECT_SOURCE_DIR}/src/ngraph")
if (NGRAPH_ONNX_IMPORT_ENABLE)
list(APPEND SRC onnx_import.cpp)
if (NGRAPH_ONNXIFI_ENABLE)
list(APPEND SRC onnxifi.cpp onnxifi_span.cpp)
endif()
endif()
if (NGRAPH_INTERPRETER_ENABLE)
list(APPEND SRC
backend_debug_api.cpp
......@@ -140,13 +133,22 @@ set(MULTI_TEST_SRC
backend_unary_elementwise.in.cpp
convolution_test.in.cpp
)
if(NGRAPH_DISTRIBUTED_ENABLE)
list(APPEND MULTI_TEST_SRC distributed.in.cpp)
endif()
if (NGRAPH_CPU_ENABLE)
list(APPEND MULTI_TEST_SRC backend_graph_comparison.in.cpp)
endif()
if (NGRAPH_ONNX_IMPORT_ENABLE)
list(APPEND MULTI_TEST_SRC onnx_import.in.cpp)
if (NGRAPH_ONNXIFI_ENABLE)
list(APPEND SRC onnxifi.cpp onnxifi_span.cpp)
endif()
endif()
foreach(BACKEND_NAME ${ACTIVE_BACKEND_LIST})
# Some---but not all---autodiff tests go through multiple iterations with
# different random seeds. On the CPU backend this is currently very slow
......
test/onnx_import.cpp → test/onnx_import.in.cpp
View file @ 2dc0c48f
......@@ -32,10 +32,12 @@
using namespace ngraph;
static std::string s_manifest = "${MANIFEST}";
using Inputs = std::vector<std::vector<float>>;
using Outputs = std::vector<std::vector<float>>;
TEST(onnx, model_output_names_check)
TEST(onnx_${BACKEND_NAME}, model_output_names_check)
{
auto function = onnx_import::import_onnx_model(
file_util::path_join(SERIALIZED_ZOO, "onnx/split_equal_parts_default.onnx"));
......@@ -48,7 +50,7 @@ TEST(onnx, model_output_names_check)
}
}
TEST(onnx, model_add_abc)
TEST(onnx_${BACKEND_NAME}, model_add_abc)
{
auto function =
onnx_import::import_onnx_model(file_util::path_join(SERIALIZED_ZOO, "onnx/add_abc.onnx"));
......@@ -56,11 +58,11 @@ TEST(onnx, model_add_abc)
Inputs inputs{{1}, {2}, {3}};
Outputs expected_outputs{{6}};
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_TRUE(test::all_close_f(expected_outputs.front(), outputs.front()));
}
TEST(onnx, model_add_abc_initializers)
TEST(onnx_${BACKEND_NAME}, model_add_abc_initializers)
{
auto function = onnx_import::import_onnx_model(
file_util::path_join(SERIALIZED_ZOO, "onnx/add_abc_initializers.onnx"));
......@@ -68,11 +70,11 @@ TEST(onnx, model_add_abc_initializers)
Inputs inputs{{1, 2, 3, 4}};
Outputs expected_outputs{{3, 6, 9, 12}};
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_TRUE(test::all_close_f(expected_outputs.front(), outputs.front()));
}
TEST(onnx, model_addmul_abc)
TEST(onnx_${BACKEND_NAME}, model_addmul_abc)
{
auto function = onnx_import::import_onnx_model(
file_util::path_join(SERIALIZED_ZOO, "onnx/addmul_abc.onnx"));
......@@ -86,11 +88,11 @@ TEST(onnx, model_addmul_abc)
auto expected_output = test::NDArray<float, 3>({{{46, 62}}, {{80, 100}}}).get_vector();
auto result_vectors = execute(function, inputs, "INTERPRETER");
auto result_vectors = execute(function, inputs, "${BACKEND_NAME}");
EXPECT_TRUE(test::all_close_f(expected_output, result_vectors.front()));
}
TEST(onnx, model_argmin_no_keepdims)
TEST(onnx_${BACKEND_NAME}, model_argmin_no_keepdims)
{
auto function = onnx_import::import_onnx_model(
file_util::path_join(SERIALIZED_ZOO, "onnx/argmin_no_keepdims.onnx"));
......@@ -98,11 +100,11 @@ TEST(onnx, model_argmin_no_keepdims)
Inputs inputs{test::NDArray<float, 2>{{2, 1}, {3, 10}}.get_vector()};
std::vector<std::vector<int64_t>> expected_output{{1, 0}};
std::vector<std::vector<int64_t>> result{
execute<float, int64_t>(function, inputs, "INTERPRETER")};
execute<float, int64_t>(function, inputs, "${BACKEND_NAME}")};
EXPECT_EQ(expected_output, result);
}
TEST(onnx, model_split_equal_parts_default)
TEST(onnx_${BACKEND_NAME}, model_split_equal_parts_default)
{
auto function = onnx_import::import_onnx_model(
file_util::path_join(SERIALIZED_ZOO, "onnx/split_equal_parts_default.onnx"));
......@@ -110,7 +112,7 @@ TEST(onnx, model_split_equal_parts_default)
Inputs inputs{{1, 2, 3, 4, 5, 6}};
Outputs expected_outputs{{1, 2}, {3, 4}, {5, 6}};
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_EQ(outputs.size(), expected_outputs.size());
for (std::size_t i = 0; i < expected_outputs.size(); ++i)
......@@ -120,7 +122,7 @@ TEST(onnx, model_split_equal_parts_default)
}
}
TEST(onnx, model_split_equal_parts_2d)
TEST(onnx_${BACKEND_NAME}, model_split_equal_parts_2d)
{
// Split into 2 equal parts along axis=1
auto function = onnx_import::import_onnx_model(
......@@ -129,7 +131,7 @@ TEST(onnx, model_split_equal_parts_2d)
Inputs inputs{{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}};
Outputs expected_outputs{{0, 1, 2, 6, 7, 8}, {3, 4, 5, 9, 10, 11}};
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_EQ(outputs.size(), expected_outputs.size());
for (std::size_t i = 0; i < expected_outputs.size(); ++i)
......@@ -139,7 +141,7 @@ TEST(onnx, model_split_equal_parts_2d)
}
}
TEST(onnx, model_split_variable_parts_2d)
TEST(onnx_${BACKEND_NAME}, model_split_variable_parts_2d)
{
// Split into variable parts {2, 4} along axis=1
auto function = onnx_import::import_onnx_model(
......@@ -148,7 +150,7 @@ TEST(onnx, model_split_variable_parts_2d)
Inputs inputs{{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}};
Outputs expected_outputs{{0, 1, 6, 7}, {2, 3, 4, 5, 8, 9, 10, 11}};
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_EQ(outputs.size(), expected_outputs.size());
for (std::size_t i = 0; i < expected_outputs.size(); ++i)
......@@ -179,12 +181,12 @@ namespace
test::NDArray<float, 4>{{{{{1.f, 1.f, 1.f}, {1.f, 1.f, 1.f}, {1.f, 1.f, 1.f}}}}}
.get_vector());
return execute(function, args, "INTERPRETER");
return execute(function, args, "${BACKEND_NAME}");
}
} // namespace
TEST(onnx, model_conv2d_strides_padding)
TEST(onnx_${BACKEND_NAME}, model_conv2d_strides_padding)
{
// Convolution with strides=2 and padding=1
auto function = onnx_import::import_onnx_model(
......@@ -201,7 +203,7 @@ TEST(onnx, model_conv2d_strides_padding)
EXPECT_EQ(expected_output, result.front());
}
TEST(onnx, model_conv2d_strides_no_padding)
TEST(onnx_${BACKEND_NAME}, model_conv2d_strides_no_padding)
{
// Convolution with strides=2 and padding=1
auto function = onnx_import::import_onnx_model(
......@@ -215,7 +217,7 @@ TEST(onnx, model_conv2d_strides_no_padding)
EXPECT_EQ(expected_output, result.front());
}
TEST(onnx, model_conv2d_strides_assymetric_padding)
TEST(onnx_${BACKEND_NAME}, model_conv2d_strides_assymetric_padding)
{
// Convolution with strides=2 and padding=1
auto function = onnx_import::import_onnx_model(
......@@ -230,7 +232,7 @@ TEST(onnx, model_conv2d_strides_assymetric_padding)
EXPECT_EQ(expected_output, result.front());
}
TEST(onnx, model_average_pool_2d)
TEST(onnx_${BACKEND_NAME}, model_average_pool_2d)
{
// Pooling with strides=2 and no padding
auto function = onnx_import::import_onnx_model(
......@@ -247,12 +249,12 @@ TEST(onnx, model_average_pool_2d)
// (1, 1, 2, 2)
auto expected_output = test::NDArray<float, 4>({{{{2.5f, 4.5f}, {10.5f, 12.5f}}}}).get_vector();
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_EQ(expected_output, outputs.front());
}
TEST(onnx, model_average_pool_2d_pads)
TEST(onnx_${BACKEND_NAME}, model_average_pool_2d_pads)
{
// Pooling with strides=2 and padding=1
auto function = onnx_import::import_onnx_model(
......@@ -271,12 +273,12 @@ TEST(onnx, model_average_pool_2d_pads)
test::NDArray<float, 4>({{{{0.f, 1.5f, 3.f}, {6.f, 7.5f, 9.f}, {12.f, 13.5f, 15.f}}}})
.get_vector();
Outputs outputs = execute(function, inputs, "INTERPRETER");
Outputs outputs = execute(function, inputs, "${BACKEND_NAME}");
EXPECT_EQ(expected_output, outputs.front());
}
TEST(onnx, model_max_pool_2d_pads)
TEST(onnx_${BACKEND_NAME}, model_max_pool_2d_pads)
{
// Pooling with strides=2 and padding=1
auto function = onnx_import::import_onnx_model(
......@@ -295,12 +297,12 @@ TEST(onnx, model_max_pool_2d_pads)
test::NDArray<float, 4>({{{{0.f, 2.f, 3.f}, {8.f, 10.f, 11.f}, {12.f, 14.f, 15.f}}}})
.get_vector();
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_EQ(expected_output, outputs.front());
}
TEST(onnx, model_batchnorm_default)
TEST(onnx_${BACKEND_NAME}, model_batchnorm_default)
{
// Batch Normalization with default parameters
auto function = onnx_import::import_onnx_model(
......@@ -326,11 +328,11 @@ TEST(onnx, model_batchnorm_default)
{{{{-0.999995f, 0.f, 0.999995f}}, {{-0.22474074f, 1.f, 2.2247407f}}}}}
.get_vector()};
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_TRUE(test::all_close_f(expected_outputs.front(), outputs.front()));
}
TEST(onnx, model_relu)
TEST(onnx_${BACKEND_NAME}, model_relu)
{
// Simple ReLU test
auto function =
......@@ -339,11 +341,11 @@ TEST(onnx, model_relu)
Inputs inputs{{-1, -2, 0, 1, 2, 3}};
Outputs expected_outputs{{0, 0, 0, 1, 2, 3}};
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_TRUE(test::all_close_f(expected_outputs.front(), outputs.front()));
}
TEST(onnx, model_sum)
TEST(onnx_${BACKEND_NAME}, model_sum)
{
// Simple Sum test
auto function =
......@@ -356,11 +358,11 @@ TEST(onnx, model_sum)
inputs.emplace_back(std::vector<float>{2.f, 6.f, 6.f});
Outputs expected_outputs{{6.f, 9.f, 12.f}};
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_TRUE(test::all_close_f(expected_outputs.front(), outputs.front()));
}
TEST(onnx, model_sum_one_input)
TEST(onnx_${BACKEND_NAME}, model_sum_one_input)
{
auto function = onnx_import::import_onnx_model(
file_util::path_join(SERIALIZED_ZOO, "onnx/sum_one_input.onnx"));
......@@ -368,11 +370,11 @@ TEST(onnx, model_sum_one_input)
// input data shape (3, )
Inputs inputs{{3.f, 0.f, 2.f}};
Outputs expected_outputs{{3.f, 0.f, 2.f}};
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_TRUE(test::all_close_f(expected_outputs.front(), outputs.front()));
}
TEST(onnx, model_min_two_inputs)
TEST(onnx_${BACKEND_NAME}, model_min_two_inputs)
{
auto function = onnx_import::import_onnx_model(
file_util::path_join(SERIALIZED_ZOO, "onnx/min_two_inputs.onnx"));
......@@ -383,11 +385,11 @@ TEST(onnx, model_min_two_inputs)
inputs.emplace_back(std::vector<float>{1.f, 4.f, 4.f});
Outputs expected_outputs{{1.f, 2.f, 1.f}};
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_TRUE(test::all_close_f(expected_outputs.front(), outputs.front()));
}
TEST(onnx, model_max)
TEST(onnx_${BACKEND_NAME}, model_max)
{
auto function =
onnx_import::import_onnx_model(file_util::path_join(SERIALIZED_ZOO, "onnx/max.onnx"));
......@@ -399,11 +401,11 @@ TEST(onnx, model_max)
inputs.emplace_back(std::vector<float>{2.f, 5.f, 3.f});
Outputs expected_outputs{{3.f, 5.f, 4.f}};
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_TRUE(test::all_close_f(expected_outputs.front(), outputs.front()));
}
TEST(onnx, model_mean)
TEST(onnx_${BACKEND_NAME}, model_mean)
{
auto function =
onnx_import::import_onnx_model(file_util::path_join(SERIALIZED_ZOO, "onnx/mean.onnx"));
......@@ -415,11 +417,11 @@ TEST(onnx, model_mean)
inputs.emplace_back(std::vector<float>{2.f, 6.f, 6.f});
Outputs expected_outputs{{2.f, 3.f, 4.f}};
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_TRUE(test::all_close_f(expected_outputs.front(), outputs.front()));
}
TEST(onnx, model_gemm_abc)
TEST(onnx_${BACKEND_NAME}, model_gemm_abc)
{
auto function =
onnx_import::import_onnx_model(file_util::path_join(SERIALIZED_ZOO, "onnx/gemm_abc.onnx"));
......@@ -445,11 +447,11 @@ TEST(onnx, model_gemm_abc)
{{340, 350.5, 361, 371.5}, {862, 890.5, 919, 947.5}, {1384, 1430.5, 1477, 1523.5}})
.get_vector()};
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_TRUE(test::all_close_f(expected_outputs.front(), outputs.front()));
}
TEST(onnx, model_matmul)
TEST(onnx_${BACKEND_NAME}, model_matmul)
{
auto function =
onnx_import::import_onnx_model(file_util::path_join(SERIALIZED_ZOO, "onnx/matmul.onnx"));
......@@ -466,11 +468,11 @@ TEST(onnx, model_matmul)
Outputs expected_outputs{
test::NDArray<float, 2>({{190, 200, 210}, {470, 496, 522}, {750, 792, 834}}).get_vector()};
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_TRUE(test::all_close_f(expected_outputs.front(), outputs.front()));
}
TEST(onnx, model_softmax)
TEST(onnx_${BACKEND_NAME}, DISABLED_model_softmax)
{
auto function =
onnx_import::import_onnx_model(file_util::path_join(SERIALIZED_ZOO, "onnx/softmax.onnx"));
......@@ -521,11 +523,11 @@ TEST(onnx, model_softmax)
6.32120559e-01f}}})
.get_vector();
auto result_vectors = execute(function, inputs, "INTERPRETER");
auto result_vectors = execute(function, inputs, "${BACKEND_NAME}");
EXPECT_TRUE(test::all_close_f(expected_output, result_vectors.front()));
}
TEST(onnx, model_concat)
TEST(onnx_${BACKEND_NAME}, model_concat)
{
auto function =
onnx_import::import_onnx_model(file_util::path_join(SERIALIZED_ZOO, "onnx/concat.onnx"));
......@@ -537,11 +539,11 @@ TEST(onnx, model_concat)
Outputs expected_outputs{test::NDArray<float, 1>({1, 2, 3, 4}).get_vector()};
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_TRUE(test::all_close_f(expected_outputs.front(), outputs.front()));
}
TEST(onnx, model_flatten)
TEST(onnx_${BACKEND_NAME}, model_flatten)
{
auto function =
onnx_import::import_onnx_model(file_util::path_join(SERIALIZED_ZOO, "onnx/flatten.onnx"));
......@@ -553,11 +555,11 @@ TEST(onnx, model_flatten)
Outputs expected_outputs{test::NDArray<float, 3>({{{1, 2, 3, 4}, {5, 6, 7, 8}}}).get_vector()};
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_TRUE(test::all_close_f(expected_outputs.front(), outputs.front()));
}
TEST(onnx, model_sub)
TEST(onnx_${BACKEND_NAME}, model_sub)
{
auto function =
onnx_import::import_onnx_model(file_util::path_join(SERIALIZED_ZOO, "onnx/sub.onnx"));
......@@ -569,11 +571,11 @@ TEST(onnx, model_sub)
auto expected_output = test::NDArray<float, 3>({{{-3, -3, -4}}}).get_vector();
auto result_vectors = execute(function, inputs, "INTERPRETER");
auto result_vectors = execute(function, inputs, "${BACKEND_NAME}");
EXPECT_TRUE(test::all_close_f(expected_output, result_vectors.front()));
}
TEST(onnx, model_unsqueeze)
TEST(onnx_${BACKEND_NAME}, model_unsqueeze)
{
auto function =
onnx_import::import_onnx_model(file_util::path_join(SERIALIZED_ZOO, "onnx/unsqueeze.onnx"));
......@@ -592,11 +594,11 @@ TEST(onnx, model_unsqueeze)
{{1, 1, 1, 1, 1}, {1, 1, 1, 1, 1}, {1, 1, 1, 1, 1}, {1, 1, 1, 1, 1}}}})
.get_vector()};
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_TRUE(test::all_close_f(expected_output.front(), outputs.front()));
}
TEST(onnx, model_squeeze)
TEST(onnx_${BACKEND_NAME}, model_squeeze)
{
auto function = onnx_import::import_onnx_model(
file_util::path_join(SERIALIZED_ZOO, "onnx/squeeze_duplicate_axes.onnx"));
......@@ -611,11 +613,11 @@ TEST(onnx, model_squeeze)
test::NDArray<float, 2>({{1.0f, 2.0f}, {3.0f, 4.0f}, {5.0f, 6.0f}, {7.0f, 8.0f}})
.get_vector()};
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_TRUE(test::all_close_f(expected_output.front(), outputs.front()));
}
TEST(onnx, model_div)
TEST(onnx_${BACKEND_NAME}, model_div)
{
auto function =
onnx_import::import_onnx_model(file_util::path_join(SERIALIZED_ZOO, "onnx/div.onnx"));
......@@ -627,11 +629,11 @@ TEST(onnx, model_div)
auto expected_output = test::NDArray<float, 3>({{{1, 0.5, 0.25}}}).get_vector();
auto result_vectors = execute(function, inputs, "INTERPRETER");
auto result_vectors = execute(function, inputs, "${BACKEND_NAME}");
EXPECT_TRUE(test::all_close_f(expected_output, result_vectors.front()));
}
TEST(onnx, model_add_bcast)
TEST(onnx_${BACKEND_NAME}, model_add_bcast)
{
auto function =
onnx_import::import_onnx_model(file_util::path_join(SERIALIZED_ZOO, "onnx/add_bcast.onnx"));
......@@ -652,11 +654,11 @@ TEST(onnx, model_add_bcast)
{{2, 3, 4, 5, 6}, {2, 3, 4, 5, 6}, {2, 3, 4, 5, 6}, {2, 3, 4, 5, 6}}}})
.get_vector()};
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_TRUE(test::all_close_f(expected_output.front(), outputs.front()));
}
TEST(onnx, model_reshape_reduced_dims)
TEST(onnx_${BACKEND_NAME}, model_reshape_reduced_dims)
{
auto function = onnx_import::import_onnx_model(
file_util::path_join(SERIALIZED_ZOO, "onnx/reshape_reduced_dims.onnx"));
......@@ -672,11 +674,11 @@ TEST(onnx, model_reshape_reduced_dims)
{12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23}})
.get_vector()};
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_TRUE(test::all_close_f(expected_outputs.front(), outputs.front()));
}
TEST(onnx, model_reshape_reordered_dims)
TEST(onnx_${BACKEND_NAME}, model_reshape_reordered_dims)
{
auto function = onnx_import::import_onnx_model(
file_util::path_join(SERIALIZED_ZOO, "onnx/reshape_reordered_dims.onnx"));
......@@ -693,11 +695,11 @@ TEST(onnx, model_reshape_reordered_dims)
{{18, 19, 20}, {21, 22, 23}}})
.get_vector()};
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_TRUE(test::all_close_f(expected_outputs.front(), outputs.front()));
}
TEST(onnx, model_reshape_extended_dims)
TEST(onnx_${BACKEND_NAME}, model_reshape_extended_dims)
{
auto function = onnx_import::import_onnx_model(
file_util::path_join(SERIALIZED_ZOO, "onnx/reshape_extended_dims.onnx"));
......@@ -713,11 +715,11 @@ TEST(onnx, model_reshape_extended_dims)
{{{16, 17}, {18, 19}}, {{20, 21}, {22, 23}}}})
.get_vector()};
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_TRUE(test::all_close_f(expected_outputs.front(), outputs.front()));
}
TEST(onnx, model_reshape_single_dim)
TEST(onnx_${BACKEND_NAME}, model_reshape_single_dim)
{
auto function = onnx_import::import_onnx_model(
file_util::path_join(SERIALIZED_ZOO, "onnx/reshape_single_dim.onnx"));
......@@ -733,11 +735,11 @@ TEST(onnx, model_reshape_single_dim)
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23})
.get_vector()};
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_TRUE(test::all_close_f(expected_outputs.front(), outputs.front()));
}
TEST(onnx, model_reshape_negative_dim)
TEST(onnx_${BACKEND_NAME}, model_reshape_negative_dim)
{
auto function = onnx_import::import_onnx_model(
file_util::path_join(SERIALIZED_ZOO, "onnx/reshape_negative_dim.onnx"));
......@@ -756,11 +758,11 @@ TEST(onnx, model_reshape_negative_dim)
{{20, 21}, {22, 23}}})
.get_vector()};
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_TRUE(test::all_close_f(expected_outputs.front(), outputs.front()));
}
TEST(onnx, model_reshape_negative_with_zero_dim)
TEST(onnx_${BACKEND_NAME}, model_reshape_negative_with_zero_dim)
{
auto function = onnx_import::import_onnx_model(
file_util::path_join(SERIALIZED_ZOO, "onnx/reshape_negative_with_zero_dims.onnx"));
......@@ -776,11 +778,11 @@ TEST(onnx, model_reshape_negative_with_zero_dim)
{{12, 13}, {14, 15}, {16, 17}, {18, 19}, {20, 21}, {22, 23}}})
.get_vector()};
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_TRUE(test::all_close_f(expected_outputs.front(), outputs.front()));
}
TEST(onnx, model_reshape_output_shape_as_input)
TEST(onnx_${BACKEND_NAME}, model_reshape_output_shape_as_input)
{
auto function = onnx_import::import_onnx_model(
file_util::path_join(SERIALIZED_ZOO, "onnx/reshape_output_shape_as_input.onnx"));
......@@ -796,11 +798,11 @@ TEST(onnx, model_reshape_output_shape_as_input)
{{12, 13}, {14, 15}, {16, 17}, {18, 19}, {20, 21}, {22, 23}}})
.get_vector()};
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_TRUE(test::all_close_f(expected_outputs.front(), outputs.front()));
}
TEST(onnx, model_reduce_log_sum)
TEST(onnx_${BACKEND_NAME}, model_reduce_log_sum)
{
auto function = onnx_import::import_onnx_model(
file_util::path_join(SERIALIZED_ZOO, "onnx/reduce_log_sum.onnx"));
......@@ -813,11 +815,11 @@ TEST(onnx, model_reduce_log_sum)
// output data shape (1,)
Outputs expected_outputs{test::NDArray<float, 4>({{{{2.77258872f}}}}).get_vector()};
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_TRUE(test::all_close_f(expected_outputs.front(), outputs.front()));
}
TEST(onnx, model_reduce_log_sum_exp)
TEST(onnx_${BACKEND_NAME}, model_reduce_log_sum_exp)
{
auto function = onnx_import::import_onnx_model(
file_util::path_join(SERIALIZED_ZOO, "onnx/reduce_log_sum_exp.onnx"));
......@@ -830,11 +832,11 @@ TEST(onnx, model_reduce_log_sum_exp)
// output data shape (1,)
Outputs expected_outputs{test::NDArray<float, 4>({{{{3.77258872f}}}}).get_vector()};
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_TRUE(test::all_close_f(expected_outputs.front(), outputs.front()));
}
TEST(onnx, model_reduce_l1)
TEST(onnx_${BACKEND_NAME}, model_reduce_l1)
{
auto function =
onnx_import::import_onnx_model(file_util::path_join(SERIALIZED_ZOO, "onnx/reduce_l1.onnx"));
......@@ -847,11 +849,11 @@ TEST(onnx, model_reduce_l1)
// output data shape (1,)
Outputs expected_outputs{test::NDArray<float, 4>({{{{16}}}}).get_vector()};
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_TRUE(test::all_close_f(expected_outputs.front(), outputs.front()));
}
TEST(onnx, model_reduce_l2)
TEST(onnx_${BACKEND_NAME}, model_reduce_l2)
{
auto function =
onnx_import::import_onnx_model(file_util::path_join(SERIALIZED_ZOO, "onnx/reduce_l2.onnx"));
......@@ -864,11 +866,11 @@ TEST(onnx, model_reduce_l2)
// output data shape (1,)
Outputs expected_outputs{test::NDArray<float, 4>({{{{4}}}}).get_vector()};
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_TRUE(test::all_close_f(expected_outputs.front(), outputs.front()));
}
TEST(onnx, model_reduce_max)
TEST(onnx_${BACKEND_NAME}, model_reduce_max)
{
auto function = onnx_import::import_onnx_model(
file_util::path_join(SERIALIZED_ZOO, "onnx/reduce_max.onnx"));
......@@ -881,11 +883,11 @@ TEST(onnx, model_reduce_max)
// output data shape (1,)
Outputs expected_outputs{test::NDArray<float, 4>({{{{16}}}}).get_vector()};
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_TRUE(test::all_close_f(expected_outputs.front(), outputs.front()));
}
TEST(onnx, model_reduce_mean)
TEST(onnx_${BACKEND_NAME}, model_reduce_mean)
{
auto function = onnx_import::import_onnx_model(
file_util::path_join(SERIALIZED_ZOO, "onnx/reduce_mean.onnx"));
......@@ -898,11 +900,11 @@ TEST(onnx, model_reduce_mean)
// output data shape (1,)
Outputs expected_outputs{test::NDArray<float, 4>({{{{1}}}}).get_vector()};
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_TRUE(test::all_close_f(expected_outputs.front(), outputs.front()));
}
TEST(onnx, model_reduce_min)
TEST(onnx_${BACKEND_NAME}, model_reduce_min)
{
auto function = onnx_import::import_onnx_model(
file_util::path_join(SERIALIZED_ZOO, "onnx/reduce_min.onnx"));
......@@ -915,11 +917,11 @@ TEST(onnx, model_reduce_min)
// output data shape (1,)
Outputs expected_outputs{test::NDArray<float, 4>({{{{1}}}}).get_vector()};
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_TRUE(test::all_close_f(expected_outputs.front(), outputs.front()));
}
TEST(onnx, model_reduce_prod)
TEST(onnx_${BACKEND_NAME}, model_reduce_prod)
{
auto function = onnx_import::import_onnx_model(
file_util::path_join(SERIALIZED_ZOO, "onnx/reduce_prod.onnx"));
......@@ -932,11 +934,11 @@ TEST(onnx, model_reduce_prod)
// output data shape (1,)
Outputs expected_outputs{test::NDArray<float, 4>({{{{1}}}}).get_vector()};
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_TRUE(test::all_close_f(expected_outputs.front(), outputs.front()));
}
TEST(onnx, model_reduce_sum)
TEST(onnx_${BACKEND_NAME}, model_reduce_sum)
{
auto function = onnx_import::import_onnx_model(
file_util::path_join(SERIALIZED_ZOO, "onnx/reduce_sum.onnx"));
......@@ -949,11 +951,11 @@ TEST(onnx, model_reduce_sum)
// output data shape (1,)
Outputs expected_outputs{test::NDArray<float, 4>({{{{16}}}}).get_vector()};
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_TRUE(test::all_close_f(expected_outputs.front(), outputs.front()));
}
TEST(onnx, model_reduce_sum_square)
TEST(onnx_${BACKEND_NAME}, model_reduce_sum_square)
{
auto function = onnx_import::import_onnx_model(
file_util::path_join(SERIALIZED_ZOO, "onnx/reduce_sum_square.onnx"));
......@@ -966,11 +968,11 @@ TEST(onnx, model_reduce_sum_square)
// output data shape (1,)
Outputs expected_outputs{test::NDArray<float, 4>({{{{16}}}}).get_vector()};
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_TRUE(test::all_close_f(expected_outputs.front(), outputs.front()));
}
TEST(onnx, model_shape)
TEST(onnx_${BACKEND_NAME}, model_shape)
{
auto function =
onnx_import::import_onnx_model(file_util::path_join(SERIALIZED_ZOO, "onnx/shape.onnx"));
......@@ -985,11 +987,11 @@ TEST(onnx, model_shape)
std::vector<std::vector<int64_t>> expected_output{{3, 4, 5}};
std::vector<std::vector<int64_t>> outputs =
execute<float, int64_t>(function, inputs, "INTERPRETER");
execute<float, int64_t>(function, inputs, "${BACKEND_NAME}");
EXPECT_TRUE(test::all_close(expected_output.front(), outputs.front()));
}
TEST(onnx, model_elu)
TEST(onnx_${BACKEND_NAME}, model_elu)
{
auto function =
onnx_import::import_onnx_model(file_util::path_join(SERIALIZED_ZOO, "onnx/elu.onnx"));
......@@ -1032,11 +1034,11 @@ TEST(onnx, model_elu)
{2, 2, 2, 2, 2}}})
.get_vector()};
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_TRUE(test::all_close_f(expected_output.front(), outputs.front()));
}
TEST(onnx, model_leaky_relu)
TEST(onnx_${BACKEND_NAME}, model_leaky_relu)
{
auto function = onnx_import::import_onnx_model(
file_util::path_join(SERIALIZED_ZOO, "onnx/leaky_relu.onnx"));
......@@ -1063,11 +1065,11 @@ TEST(onnx, model_leaky_relu)
{2, 2, 2, 2, 2}}})
.get_vector()};
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_TRUE(test::all_close_f(expected_output.front(), outputs.front()));
}
TEST(onnx, prelu)
TEST(onnx_${BACKEND_NAME}, prelu)
{
auto function =
onnx_import::import_onnx_model(file_util::path_join(SERIALIZED_ZOO, "onnx/prelu.onnx"));
......@@ -1093,11 +1095,11 @@ TEST(onnx, prelu)
{{1, 1, 1, 1, 1}, {0, -1, 0, -1, 0}, {0, 0, 0, 0, 0}, {2, 2, 2, 2, 2}}})
.get_vector()};
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_TRUE(test::all_close_f(expected_output.front(), outputs.front()));
}
TEST(onnx, model_selu)
TEST(onnx_${BACKEND_NAME}, model_selu)
{
auto function =
onnx_import::import_onnx_model(file_util::path_join(SERIALIZED_ZOO, "onnx/selu.onnx"));
......@@ -1134,11 +1136,11 @@ TEST(onnx, model_selu)
{6, 6, 6, 6, 6}}})
.get_vector()};
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_TRUE(test::all_close_f(expected_output.front(), outputs.front()));
}
TEST(onnx, model_sigmoid)
TEST(onnx_${BACKEND_NAME}, model_sigmoid)
{
auto function =
onnx_import::import_onnx_model(file_util::path_join(SERIALIZED_ZOO, "onnx/sigmoid.onnx"));
......@@ -1209,11 +1211,11 @@ TEST(onnx, model_sigmoid)
0.880797077977882f}}})
.get_vector()};
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_TRUE(test::all_close_f(expected_output.front(), outputs.front()));
}
TEST(onnx, model_tanh)
TEST(onnx_${BACKEND_NAME}, model_tanh)
{
auto function =
onnx_import::import_onnx_model(file_util::path_join(SERIALIZED_ZOO, "onnx/tanh.onnx"));
......@@ -1284,11 +1286,11 @@ TEST(onnx, model_tanh)
0.964027580075817f}}})
.get_vector()};
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_TRUE(test::all_close_f(expected_output.front(), outputs.front()));
}
TEST(onnx, model_thresholded_relu)
TEST(onnx_${BACKEND_NAME}, model_thresholded_relu)
{
auto function = onnx_import::import_onnx_model(
file_util::path_join(SERIALIZED_ZOO, "onnx/thresholded_relu.onnx"));
......@@ -1308,11 +1310,11 @@ TEST(onnx, model_thresholded_relu)
{{0, 0, 0, 0, 0}, {0, 0, 0, 0, 0}, {0, 0, 0, 0, 0}, {0, 0, 0, 0, 0}}})
.get_vector()};
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_TRUE(test::all_close_f(expected_output.front(), outputs.front()));
}
TEST(onnx, model_unsupported_op)
TEST(onnx_${BACKEND_NAME}, model_unsupported_op)
{
try
{
......@@ -1333,7 +1335,7 @@ TEST(onnx, model_unsupported_op)
}
}
TEST(onnx, model_custom_op)
TEST(onnx_${BACKEND_NAME}, model_custom_op)
{
onnx_import::register_operator(
"AddQ", 1, "com.intel.ai", [](const onnx_import::Node& node) -> NodeVector {
......@@ -1347,11 +1349,11 @@ TEST(onnx, model_custom_op)
Inputs inputs{{1, 2, 3, 4}};
Outputs expected_outputs{{3, 6, 9, 12}};
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_TRUE(test::all_close_f(expected_outputs.front(), outputs.front()));
}
TEST(onnx, model_custom_op_default_domain)
TEST(onnx_${BACKEND_NAME}, model_custom_op_default_domain)
{
onnx_import::register_operator(
"AddQ", 1, "com.intel.ai", [](const onnx_import::Node& node) -> NodeVector {
......@@ -1365,11 +1367,11 @@ TEST(onnx, model_custom_op_default_domain)
Inputs inputs{{1, 2, 3, 4}};
Outputs expected_outputs{{3, 6, 9, 12}};
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_TRUE(test::all_close_f(expected_outputs.front(), outputs.front()));
}
TEST(onnx, model_conv2d_dilation_assymetric_pads_strides)
TEST(onnx_${BACKEND_NAME}, model_conv2d_dilation_assymetric_pads_strides)
{
auto function = onnx_import::import_onnx_model(
file_util::path_join(SERIALIZED_ZOO, "onnx/conv2d_dilation_assym_pads_strides.onnx"));
......@@ -1405,11 +1407,11 @@ TEST(onnx, model_conv2d_dilation_assymetric_pads_strides)
{{-0.10154513269662857f, -0.13448859751224518f}}}})
.get_vector()};
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_TRUE(test::all_close_f(expected_output.front(), outputs.front()));
}
TEST(onnx, model_conv3d_bias)
TEST(onnx_${BACKEND_NAME}, model_conv3d_bias)
{
auto function = onnx_import::import_onnx_model(
file_util::path_join(SERIALIZED_ZOO, "onnx/conv3d_bias.onnx"));
......@@ -1519,11 +1521,11 @@ TEST(onnx, model_conv3d_bias)
-0.39770257472991943f, -0.45317384600639343f, -0.5598302483558655f, -0.2542789578437805f,
-0.5359901785850525f, -0.48090484738349915f, -0.38603779673576355f, -0.4991581439971924f}};
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_TRUE(test::all_close_f(expected_output.front(), outputs.front()));
}
TEST(onnx, model_matmul_vec_ten3d)
TEST(onnx_${BACKEND_NAME}, model_matmul_vec_ten3d)
{
auto function = onnx_import::import_onnx_model(
file_util::path_join(SERIALIZED_ZOO, "onnx/matmul_vec_ten3d.onnx"));
......@@ -1535,11 +1537,11 @@ TEST(onnx, model_matmul_vec_ten3d)
Outputs expected_output{test::NDArray<float, 2>{{1.f}, {3.f}, {5.f}}};
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_TRUE(test::all_close_f(expected_output.front(), outputs.front()));
}
TEST(onnx, model_softplus)
TEST(onnx_${BACKEND_NAME}, DISABLED_model_softplus)
{
auto function =
onnx_import::import_onnx_model(file_util::path_join(SERIALIZED_ZOO, "onnx/softplus.onnx"));
......@@ -1578,7 +1580,7 @@ TEST(onnx, model_softplus)
std::transform(std::begin(input), std::end(input), std::back_inserter(output), softplus_impl);
Outputs expected_output{output};
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_TRUE(test::all_close_f(expected_output.front(), outputs.front()));
inputs.clear();
......@@ -1599,7 +1601,7 @@ TEST(onnx, model_softplus)
std::numeric_limits<float>::infinity(),
std::numeric_limits<float>::infinity()});
input = inputs.back();
outputs = execute(function, inputs, "INTERPRETER");
outputs = execute(function, inputs, "${BACKEND_NAME}");
for (float v : outputs.front())
{
......@@ -1607,7 +1609,7 @@ TEST(onnx, model_softplus)
}
}
TEST(onnx, model_sum_opset8)
TEST(onnx_${BACKEND_NAME}, model_sum_opset8)
{
auto function = onnx_import::import_onnx_model(
file_util::path_join(SERIALIZED_ZOO, "onnx/sum_opset8.onnx"));
......@@ -1625,11 +1627,11 @@ TEST(onnx, model_sum_opset8)
{{311.0f, 312.0f, 313.0f}, {321.0f, 322.0f, 323.0f}, {331.0f, 332.0f, 333.0f}}}
.get_vector()};
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_TRUE(test::all_close_f(expected_output.front(), outputs.front()));
}
TEST(onnx, model_conv_transpose_w_groups)
TEST(onnx_${BACKEND_NAME}, model_conv_transpose_w_groups)
{
auto function = onnx_import::import_onnx_model(
file_util::path_join(SERIALIZED_ZOO, "onnx/conv_transpose_w_groups.onnx"));
......@@ -1644,11 +1646,11 @@ TEST(onnx, model_conv_transpose_w_groups)
Outputs expected_output{
std::vector<float>{28.f, 34.f, 252.f, 274.f, 732.f, 770.f, 1468.f, 1522.f}};
Outputs outputs{execute(function, inputs, "INTERPRETER")};
Outputs outputs{execute(function, inputs, "${BACKEND_NAME}")};
EXPECT_TRUE(test::all_close_f(expected_output.front(), outputs.front()));
}
TEST(onnx, model_argmax_int32)
TEST(onnx_${BACKEND_NAME}, model_argmax_int32)
{
auto function = onnx_import::import_onnx_model(
file_util::path_join(SERIALIZED_ZOO, "onnx/argmax_int32.onnx"));
......@@ -1660,11 +1662,11 @@ TEST(onnx, model_argmax_int32)
std::vector<std::int64_t>{1, 1, 1, 1, 1, 1}};
std::vector<std::vector<std::int64_t>> outputs{
execute<std::int32_t, std::int64_t>(function, inputs, "INTERPRETER")};
execute<std::int32_t, std::int64_t>(function, inputs, "${BACKEND_NAME}")};
EXPECT_TRUE(test::all_close(expected_output.front(), outputs.front()));
}
TEST(onnx, model_argmin_int32)
TEST(onnx_${BACKEND_NAME}, model_argmin_int32)
{
auto function = onnx_import::import_onnx_model(
file_util::path_join(SERIALIZED_ZOO, "onnx/argmin_int32.onnx"));
......@@ -1675,11 +1677,11 @@ TEST(onnx, model_argmin_int32)
std::vector<std::vector<std::int64_t>> expected_output{std::vector<std::int64_t>{0, 0, 0, 0}};
std::vector<std::vector<std::int64_t>> outputs{
execute<std::int32_t, std::int64_t>(function, inputs, "INTERPRETER")};
execute<std::int32_t, std::int64_t>(function, inputs, "${BACKEND_NAME}")};
EXPECT_TRUE(test::all_close(expected_output.front(), outputs.front()));
}
TEST(onnx, model_is_op_supported)
TEST(onnx_${BACKEND_NAME}, is_op_supported)
{
// Simple case
EXPECT_TRUE(onnx_import::is_operator_supported("Sum", 1, "ai.onnx"));
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment