Unverified Commit 21e73812 authored by Adam Procter's avatar Adam Procter Committed by GitHub

Merge branch 'master' into krovatkin/ml_reuse_debug

parents 1f0c8d31 ec86e1a8
......@@ -6,11 +6,11 @@
/cmake/ @rkimballn1 @silee2
/.ci/ @aslepko @crlishka
/.ci/travis/ @postrational
/.ci/onnx/ @postrational
/contrib/docker/ @aslepko @crlishka
/.travis.yml @postrational
/.ci/ @aslepko
/.ci/travis/ @aslepko @postrational
/.ci/onnx/ @aslepko @postrational
/contrib/docker/ @aslepko
/.travis.yml @aslepko @postrational
/.clang-format @rkimballn1
/.gitattributes @rkimballn1
......
......@@ -42,3 +42,7 @@ add_custom_command(
)
add_custom_target(python_wheel DEPENDS ngraph ${CMAKE_BINARY_DIR}/python/dist/)
if (NGRAPH_CPU_ENABLE)
add_dependencies(python_wheel ext_mkldnn)
endif()
......@@ -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
......
......@@ -374,6 +374,10 @@ class BuildExt(build_ext):
build_ext.build_extensions(self)
if sys.platform == 'darwin':
# This turns out to be needed when building using Anaconda python on macOS.
os.environ['MACOSX_DEPLOYMENT_TARGET'] = '10.9'
with open(os.path.join(PYNGRAPH_ROOT_DIR, 'requirements.txt')) as req:
requirements = req.read().splitlines()
......
......@@ -99,6 +99,14 @@ namespace ngraph
return op_list;
}
bool is_operator_supported(const std::string& op_name,
std::int64_t version,
const std::string& domain)
{
return OperatorsBridge::is_operator_registered(
op_name, version, domain == "ai.onnx" ? "" : domain);
}
} // namespace onnx_import
} // namespace ngraph
......@@ -52,6 +52,18 @@ namespace ngraph
std::set<std::string> get_supported_operators(std::int64_t version,
const std::string& domain);
/// \brief Determines whether ONNX operator is supported.
///
/// \param[in] op_name The ONNX operator name.
/// \param[in] version The ONNX operator set version.
/// \param[in] domain The domain the ONNX operator is registered to.
///
/// \return True if operator is supported, False otherwise.
///
bool is_operator_supported(const std::string& op_name,
std::int64_t version,
const std::string& domain = "ai.onnx");
/// \brief Convert an ONNX model to nGraph function
/// The function translated serialized ONNX model to nGraph function. The serialized
/// ONNX model is read from input stream.
......
......@@ -21,6 +21,7 @@
#include <unordered_map>
#include "core/attribute.hpp"
#include "ngraph/log.hpp"
#include "op/abs.hpp"
#include "op/acos.hpp"
#include "op/add.hpp"
......@@ -102,20 +103,19 @@ namespace ngraph
{
namespace detail
{
const Operator& find(const std::string& name,
std::int64_t version,
const std::string& domain,
const std::map<std::int64_t, Operator>& map)
const std::map<std::int64_t, Operator>::const_iterator
find(std::int64_t version, const std::map<std::int64_t, Operator>& map)
{
std::map<std::int64_t, Operator>::const_iterator it{};
while (version > 0)
{
const auto it = map.find(version--);
it = map.find(version--);
if (it != std::end(map))
{
return it->second;
return it;
}
}
throw error::UnsupportedVersion{name, version, domain};
return it;
}
}
......@@ -136,13 +136,51 @@ namespace ngraph
{
throw error::UnknownDomain{domain};
}
if (version > OperatorsBridge::LATEST_SUPPORTED_OPSET_VERSION)
{
NGRAPH_WARN << "Currently operator set version: " << version << " is unsupported."
<< " Falling back to: "
<< OperatorsBridge::LATEST_SUPPORTED_OPSET_VERSION;
}
for (const auto& op : dm->second)
{
result.emplace(op.first, detail::find(op.first, version, domain, op.second));
const auto& it = detail::find(version, op.second);
if (it == std::end(op.second))
{
throw error::UnsupportedVersion{op.first, version, domain};
}
result.emplace(op.first, it->second);
}
return result;
}
bool OperatorsBridge::_is_operator_registered(const std::string& name,
std::int64_t version,
const std::string& domain)
{
// search for domain
auto dm_map = m_map.find(domain);
if (dm_map == std::end(m_map))
{
return false;
}
// search for name
auto op_map = dm_map->second.find(name);
if (op_map == std::end(dm_map->second))
{
return false;
}
if (detail::find(version, op_map->second) != std::end(op_map->second))
{
return true;
}
else
{
return false;
}
}
#define REGISTER_OPERATOR(name_, ver_, fn_) \
m_map[""][name_].emplace(ver_, std::bind(op::set_##ver_::fn_, std::placeholders::_1))
......
......@@ -62,6 +62,8 @@ namespace ngraph
class OperatorsBridge
{
public:
static constexpr const int LATEST_SUPPORTED_OPSET_VERSION = ONNX_OPSET_VERSION;
OperatorsBridge(const OperatorsBridge&) = delete;
OperatorsBridge& operator=(const OperatorsBridge&) = delete;
OperatorsBridge(OperatorsBridge&&) = delete;
......@@ -80,6 +82,13 @@ namespace ngraph
instance()._register_operator(name, version, domain, std::move(fn));
}
static bool is_operator_registered(const std::string& name,
std::int64_t version,
const std::string& domain)
{
return instance()._is_operator_registered(name, version, domain);
}
private:
std::unordered_map<std::string,
std::unordered_map<std::string, std::map<std::int64_t, Operator>>>
......@@ -98,6 +107,9 @@ namespace ngraph
const std::string& domain,
Operator fn);
OperatorSet _get_operator_set(std::int64_t version, const std::string& domain);
bool _is_operator_registered(const std::string& name,
std::int64_t version,
const std::string& domain);
};
} // namespace onnx_import
......
......@@ -29,22 +29,30 @@
#include "ngraph/op/convolution.hpp"
#include "ngraph/op/dequantize.hpp"
#include "ngraph/op/get_output_element.hpp"
#include "ngraph/op/pad.hpp"
#include "ngraph/op/quantize.hpp"
#include "ngraph/op/reshape.hpp"
#include "ngraph/op/slice.hpp"
#include "ngraph/op/util/binary_elementwise_arithmetic.hpp"
#include "ngraph/op/util/unary_elementwise_arithmetic.hpp"
#include "ngraph/pattern/op/label.hpp"
#include "ngraph/util.hpp"
using namespace ngraph;
extern template ngraph::AxisVector
ngraph::apply_permutation<ngraph::AxisVector>(ngraph::AxisVector input,
ngraph::AxisVector order);
using ReshapeMap = std::unordered_map<std::shared_ptr<Node>, std::shared_ptr<op::Reshape>>;
extern template ngraph::Shape ngraph::apply_permutation<ngraph::Shape>(ngraph::Shape input,
ngraph::AxisVector order);
static std::string describe_reshape(std::shared_ptr<Node> node)
{
std::stringstream ss;
auto reshape = std::dynamic_pointer_cast<op::Reshape>(node);
ss << reshape->get_name()
<< " ( axis order = " << ngraph::vector_to_string(reshape->get_input_order())
<< " , shape = " << vector_to_string(reshape->get_shape()) << " ) "
<< " , child = " << reshape->get_argument(0)->get_name();
using ReshapeMap = std::unordered_map<std::shared_ptr<Node>, std::shared_ptr<op::Reshape>>;
return ss.str();
}
static std::shared_ptr<op::Reshape> combine_reshapes(std::shared_ptr<op::Reshape> r1,
std::shared_ptr<op::Reshape> r2)
......@@ -64,18 +72,6 @@ static void
target->get_inputs().at(input_index).replace_output(new_reshape->get_outputs().at(0));
}
std::string describe_reshape(std::shared_ptr<Node> node)
{
std::stringstream ss;
auto reshape = std::dynamic_pointer_cast<op::Reshape>(node);
ss << reshape->get_name()
<< " ( axis order = " << ngraph::vector_to_string(reshape->get_input_order())
<< " , shape = " << vector_to_string(reshape->get_shape()) << " ) "
<< " , child = " << reshape->get_argument(0)->get_name();
return ss.str();
}
static void delete_reshape(std::shared_ptr<Node> reshape)
{
NGRAPH_DEBUG << "Removing reshape " << reshape->get_name();
......@@ -256,6 +252,7 @@ static void sink_reshape(std::shared_ptr<op::Reshape> reshape,
mark_reshape_for_deletion(orig_reshape, reshapes_to_delete);
//replace reshape with combined one
ngraph::replace_node(reshape, new_reshape);
mark_reshape_for_deletion(new_reshape, reshapes_to_delete);
reorders[new_reshape] = new_reshape;
NGRAPH_DEBUG << "Combining " << describe_reshape(orig_reshape) << " and"
<< describe_reshape(reshape) << " into " << describe_reshape(new_reshape);
......@@ -309,6 +306,61 @@ static void sink_binary(std::shared_ptr<op::util::BinaryElementwiseArithmetic> b
}
}
static void sink_slice(std::shared_ptr<op::Slice> n,
ReshapeMap& reorders,
std::set<std::shared_ptr<Node>>& reshapes_to_delete)
{
auto arg_reshape = reorders.at(n->get_argument(0));
auto order = arg_reshape->get_input_order();
// we need the correct input shape to produce the right output shape
// we are going to create a label of the right input shape,
// so a new slice will have the right shape
auto def_order = ngraph::get_permutation_to_default_order(order);
auto input_shape = ngraph::apply_permutation(arg_reshape->get_shape(), def_order);
auto dummy_correct_shape =
std::make_shared<pattern::op::Label>(arg_reshape->get_element_type(), input_shape);
auto new_lower = ngraph::apply_permutation(n->get_lower_bounds(), def_order);
auto new_upper = ngraph::apply_permutation(n->get_upper_bounds(), def_order);
auto new_strides = ngraph::apply_permutation(n->get_strides(), def_order);
auto new_slice =
std::make_shared<op::Slice>(dummy_correct_shape, new_lower, new_upper, new_strides);
ngraph::replace_node(dummy_correct_shape, n->get_argument(0));
NGRAPH_DEBUG << "Replacing " << n->get_name() << " with " << new_slice->get_name();
ngraph::replace_node(n, new_slice);
auto new_reshape = std::make_shared<op::Reshape>(new_slice, order, n->get_shape());
NGRAPH_DEBUG << "Propagating " << describe_reshape(new_reshape) << " for " << n->get_name();
reorders[new_slice] = new_reshape;
}
static void sink_pad(std::shared_ptr<op::Pad> n,
ReshapeMap& reorders,
std::set<std::shared_ptr<Node>>& reshapes_to_delete)
{
auto arg_reshape = reorders.at(n->get_argument(0));
auto order = arg_reshape->get_input_order();
// we need the correct input shape to produce the right output shape
// we are going to create a label of the right input shape,
// so a new pad will have the right shape
auto def_order = ngraph::get_permutation_to_default_order(order);
auto input_shape = ngraph::apply_permutation(arg_reshape->get_shape(), def_order);
auto dummy_correct_shape =
std::make_shared<pattern::op::Label>(arg_reshape->get_element_type(), input_shape);
auto new_lower = ngraph::apply_permutation(n->get_padding_below(), def_order);
auto new_upper = ngraph::apply_permutation(n->get_padding_above(), def_order);
auto new_interior = ngraph::apply_permutation(n->get_padding_interior(), def_order);
auto new_pad = std::make_shared<op::Pad>(
dummy_correct_shape, n->get_argument(1), new_lower, new_upper, new_interior);
ngraph::replace_node(dummy_correct_shape, n->get_argument(0));
NGRAPH_DEBUG << "Replacing " << n->get_name() << " with " << new_pad->get_name();
ngraph::replace_node(n, new_pad);
auto new_reshape = std::make_shared<op::Reshape>(new_pad, order, n->get_shape());
NGRAPH_DEBUG << "Propagating " << describe_reshape(new_reshape) << " for " << n->get_name();
reorders[new_pad] = new_reshape;
}
static void sink_quantize(std::shared_ptr<op::Quantize> quantize,
ReshapeMap& reorders,
std::set<std::shared_ptr<Node>>& reshapes_to_delete)
......@@ -419,6 +471,14 @@ bool ngraph::pass::ReshapeSinking::run_on_function(std::shared_ptr<ngraph::Funct
{
sink_dequantize(dequantize, reorders, reshapes_to_delete);
}
else if (auto slice = std::dynamic_pointer_cast<op::Slice>(n))
{
sink_slice(slice, reorders, reshapes_to_delete);
}
else if (auto pad = std::dynamic_pointer_cast<op::Pad>(n))
{
sink_pad(pad, reorders, reshapes_to_delete);
}
else
{
materialize_shapes(n, reorders, reshapes_to_delete);
......
......@@ -17,6 +17,7 @@
#pragma once
#include "ngraph/pass/pass.hpp"
#include "ngraph/util.hpp"
namespace ngraph
{
......@@ -29,3 +30,17 @@ namespace ngraph
};
}
}
extern template ngraph::AxisVector
ngraph::apply_permutation<ngraph::AxisVector>(ngraph::AxisVector input,
ngraph::AxisVector order);
extern template ngraph::Coordinate
ngraph::apply_permutation<ngraph::Coordinate>(ngraph::Coordinate input,
ngraph::AxisVector order);
extern template ngraph::Strides
ngraph::apply_permutation<ngraph::Strides>(ngraph::Strides input, ngraph::AxisVector order);
extern template ngraph::Shape ngraph::apply_permutation<ngraph::Shape>(ngraph::Shape input,
ngraph::AxisVector order);
......@@ -145,3 +145,8 @@ vector<runtime::PerformanceCounter>
}
return rc;
}
bool runtime::cpu::CPU_Backend::is_supported(const Node& op) const
{
return true;
}
......@@ -58,6 +58,8 @@ namespace ngraph
std::vector<PerformanceCounter>
get_performance_data(std::shared_ptr<Function> func) const override;
bool is_supported(const Node& node) const override;
private:
class FunctionInstance
{
......
......@@ -1982,10 +1982,10 @@ void runtime::cpu::CPU_ExternalFunction::build()
file_util::path_join(s_debug_dir, m_function_name + "_debug.txt");
std::stringstream ss;
ss << "EXECUTION PLAN:\n";
ss << "\nEXECUTION PLAN:\n";
for (size_t i = 0; i < functors.size(); i++)
{
ss << op_names.at(i) << "will be executed with the following inputs:\n";
ss << op_names.at(i) << " will be executed with the following inputs:\n";
for (auto is : this->m_op_attrs.at(i).Inputs)
{
ss << "\t" << is << " = " << this->get_tensor_data(is) << std::endl;
......
......@@ -18,13 +18,10 @@
#include "ngraph/graph_util.hpp"
#include "ngraph/pass/manager.hpp"
#include "ngraph/pass/visualize_tree.hpp"
#include "ngraph/runtime/gpu/gpu_backend.hpp"
#include "ngraph/runtime/gpu/gpu_tensor.hpp"
#include "ngraph/runtime/host_tensor.hpp"
#include "ngraph/runtime/hybrid/hybrid_util.hpp"
#include "ngraph/runtime/hybrid/pass/assign_placement.hpp"
#include "ngraph/runtime/hybrid/pass/fix_get_output_element.hpp"
#include "ngraph/runtime/interpreter/int_backend.hpp"
#include "ngraph/runtime/tensor.hpp"
using namespace ngraph;
......@@ -205,32 +202,6 @@ bool runtime::hybrid::HybridBackend::is_supported(const Node& node) const
return true;
}
string runtime::hybrid::HybridBackend::get_placement_name(const runtime::Tensor* t)
{
string rc;
if (dynamic_cast<const runtime::HostTensor*>(t) != nullptr)
{
rc = "HostTensor";
}
else if (dynamic_cast<const runtime::gpu::GPUTensor*>(t) != nullptr)
{
rc = "GPUTensor";
}
return rc;
}
string runtime::hybrid::HybridBackend::get_placement_name(const runtime::Backend* t)
{
string rc;
if (dynamic_cast<const runtime::interpreter::INTBackend*>(t) != nullptr)
{
rc = "INTBackend";
}
else if (dynamic_cast<const runtime::gpu::GPU_Backend*>(t) != nullptr)
{
rc = "GPU_Backend";
}
return rc;
}
size_t runtime::hybrid::HybridBackend::get_placement(const runtime::Tensor* t)
{
size_t index = 0;
......
......@@ -70,7 +70,5 @@ private:
std::map<std::shared_ptr<ngraph::Function>, FunctionInstance> m_function_map;
std::vector<std::shared_ptr<runtime::Backend>> m_backend_list;
std::string get_placement_name(const runtime::Tensor* t);
std::string get_placement_name(const runtime::Backend* t);
size_t get_placement(const runtime::Tensor* t);
};
......@@ -478,6 +478,10 @@ T ngraph::apply_permutation(T input, AxisVector order)
template AxisVector ngraph::apply_permutation<AxisVector>(AxisVector input, AxisVector order);
template Shape ngraph::apply_permutation<Shape>(Shape input, AxisVector order);
template ngraph::Coordinate ngraph::apply_permutation<ngraph::Coordinate>(ngraph::Coordinate input,
ngraph::AxisVector order);
template ngraph::Strides ngraph::apply_permutation<ngraph::Strides>(ngraph::Strides input,
ngraph::AxisVector order);
AxisVector ngraph::get_default_order(const Shape& shape)
{
......
......@@ -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
......
......@@ -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, "CPU")};
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,6 +1677,37 @@ 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, "CPU")};
execute<std::int32_t, std::int64_t>(function, inputs, "${BACKEND_NAME}")};
EXPECT_TRUE(test::all_close(expected_output.front(), outputs.front()));
}
TEST(onnx_${BACKEND_NAME}, is_op_supported)
{
// Simple case
EXPECT_TRUE(onnx_import::is_operator_supported("Sum", 1, "ai.onnx"));
// With fallback
EXPECT_TRUE(onnx_import::is_operator_supported("Sum", 100, "ai.onnx"));
// Different opset versions
EXPECT_TRUE(onnx_import::is_operator_supported("Add", 1, "ai.onnx"));
EXPECT_TRUE(onnx_import::is_operator_supported("Add", 7, "ai.onnx"));
// Default domain name
EXPECT_TRUE(onnx_import::is_operator_supported("Sum", 1));
// Unregistered operator
EXPECT_FALSE(onnx_import::is_operator_supported("DummyOp", 1));
EXPECT_FALSE(onnx_import::is_operator_supported("DummyOp", 1, "ai.onnx"));
EXPECT_FALSE(onnx_import::is_operator_supported("DummyOp", 10, "ai.onnx"));
// Operator with bad domain name
EXPECT_FALSE(onnx_import::is_operator_supported("Sum", 1, "bad.domain"));
// Registered custom operator
onnx_import::register_operator(
"AddQ", 1, "com.intel.ai", [](const onnx_import::Node& node) -> NodeVector {
NodeVector ng_inputs{node.get_ng_inputs()};
return {std::make_shared<ngraph::op::Add>(ng_inputs.at(0), ng_inputs.at(1))};
});
EXPECT_TRUE(onnx_import::is_operator_supported("AddQ", 1, "com.intel.ai"));
}
......@@ -163,3 +163,43 @@ TEST(reshape_sinking, nasnet_pooladd)
size_t before_after = count_ops_of_type<op::Reshape>(func);
ASSERT_LE(before_after, before_count);
}
TEST(reshape_sinking, slice_pad)
{
Shape shape_a{100, 8, 8, 1};
AxisVector to_nhwc{0, 2, 3, 1};
AxisVector to_nchw{0, 3, 1, 2};
auto A = make_shared<op::Parameter>(element::f32, shape_a);
auto pad_value = op::Constant::create<float>(element::f32, Shape{}, std::vector<float>{0.0f});
Shape padding_below{0, 0, 0, 0};
Shape padding_above{0, 1, 1, 0};
Shape padding_interior{0, 0, 0, 0};
auto reshape1 = make_shared<op::Reshape>(A, to_nchw, Shape{100, 1, 8, 8});
auto maxpool =
make_shared<op::MaxPool>(reshape1, Shape{1, 1}, Strides{2, 2}, Shape{0, 0}, Shape{0, 0});
auto reshape2 = make_shared<op::Reshape>(maxpool, to_nhwc, Shape{100, 4, 4, 1});
auto pad =
make_shared<op::Pad>(reshape2, pad_value, padding_below, padding_above, padding_interior);
auto slice = make_shared<op::Slice>(
pad, Coordinate{0, 1, 1, 0}, Coordinate{100, 5, 5, 1}, Strides{1, 1, 1, 1});
auto reshape3 = make_shared<op::Reshape>(slice, to_nchw, Shape{100, 1, 4, 4});
auto avgpool = make_shared<op::AvgPool>(reshape3, Shape{1, 1}, Strides{2, 2});
auto reshape4 = make_shared<op::Reshape>(avgpool, to_nhwc, Shape{100, 1, 2, 2});
auto f = make_shared<Function>(reshape4, ParameterVector{A});
pass::Manager pass_manager;
size_t before_count = count_ops_of_type<op::Reshape>(f);
pass_manager.register_pass<pass::VisualizeTree>("before.pdf");
pass_manager.register_pass<pass::ReshapeSinking>();
pass_manager.register_pass<pass::ReshapeElimination>();
pass_manager.register_pass<pass::CommonSubexpressionElimination>();
pass_manager.register_pass<pass::VisualizeTree>("after.pdf");
pass_manager.run_passes(f);
size_t before_after = count_ops_of_type<op::Reshape>(f);
ASSERT_LE(before_after, before_count);
}
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