IntenseWebs/openvino
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

NodeVector -> OutputVector replacement (#1272)

Browse Source
This commit is contained in:
Katarzyna Mitrus 2020-07-29 17:18:56 +02:00 committed by GitHub
parent dec7df17ed
commit f34511642a
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
294 changed files with 882 additions and 900 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
inference-engine/src/transformations/src/transformations/convert_batch_to_space.cpp
View File

@ -23,8 +23,8 @@ void ngraph::pass::ConvertBatchToSpace::convert_batch_to_space() {
return false;
}
auto last_node = batch_to_space->decompose_op()[0];
last_node->set_friendly_name(batch_to_space->get_friendly_name());
ngraph::replace_node(batch_to_space, last_node);
last_node.get_node()->set_friendly_name(batch_to_space->get_friendly_name());
ngraph::replace_node(batch_to_space, last_node.get_node_shared_ptr());
return true;
};

4
inference-engine/src/transformations/src/transformations/convert_space_to_batch.cpp
View File

@ -23,8 +23,8 @@ void ngraph::pass::ConvertSpaceToBatch::convert_space_to_batch() {
return false;
}
auto last_node = space_to_batch->decompose_op()[0];
last_node->set_friendly_name(space_to_batch->get_friendly_name());
ngraph::replace_node(space_to_batch, last_node);
last_node.get_node()->set_friendly_name(space_to_batch->get_friendly_name());
ngraph::replace_node(space_to_batch, last_node.get_node_shared_ptr());
return true;
};

2
ngraph/src/ngraph/builder/matmul_factory.cpp
View File

@ -68,7 +68,7 @@ Output<Node> builder::MatmulFactory::get_right()
return m_inputs.at(1);
}
NodeVector builder::MatmulFactory::make_matmul_op()
OutputVector builder::MatmulFactory::make_matmul_op()
{
auto left = get_left();
auto right = get_right();

4
ngraph/src/ngraph/builder/matmul_factory.hpp
View File

@ -40,8 +40,8 @@ namespace ngraph
/// \brief Create a sub-graph representing an ONNX MatMul operation.
///
/// \return NodeVector containing the sub-graph output node.
virtual NodeVector make_matmul_op();
/// \return OutputVector containing the sub-graph output node.
virtual OutputVector make_matmul_op();
protected:
/// \return Output representing the left operand.

15
ngraph/src/ngraph/builder/quantization_utils.cpp
View File

@ -172,8 +172,9 @@ namespace ngraph
}
}
void
check_concat(const NodeVector& args, const NodeVector& mins, const NodeVector& maxs)
void check_concat(const OutputVector& args,
const OutputVector& mins,
const OutputVector& maxs)
{
auto size = args.size();
if (size != mins.size() || size != maxs.size())
@ -184,17 +185,17 @@ namespace ngraph
{
auto min = mins[i];
auto max = maxs[i];
auto type = min->get_element_type();
if (type != max->get_element_type())
auto type = min.get_element_type();
if (type != max.get_element_type())
{
throw ngraph_error("check_concat: min and max must have same type");
}
if (min->get_shape() != Shape{1} || max->get_shape() != Shape{1})
if (min.get_shape() != Shape{1} || max.get_shape() != Shape{1})
{
throw ngraph_error("check_concat: min/max shape not Shape{1}: " +
vector_to_string(min->get_shape()) +
vector_to_string(max->get_shape()));
vector_to_string(min.get_shape()) +
vector_to_string(max.get_shape()));
}
}
}

6
ngraph/src/ngraph/builder/quantization_utils.hpp
View File

@ -64,9 +64,9 @@ namespace ngraph
const ngraph::element::Type& output_type,
const bool requantize = true);
void check_concat(const NodeVector& args,
const NodeVector& mins,
const NodeVector& maxs);
void check_concat(const OutputVector& args,
const OutputVector& mins,
const OutputVector& maxs);
}
}
}

16
ngraph/src/ngraph/builder/quantized_concat_builder.cpp
View File

@ -25,28 +25,28 @@ namespace ngraph
{
namespace builder
{
shared_ptr<Node> QuantizedConcatBuilder(const NodeVector& args,
shared_ptr<Node> QuantizedConcatBuilder(const OutputVector& args,
size_t concatenation_axis,
const NodeVector& mins,
const NodeVector& maxs)
const OutputVector& mins,
const OutputVector& maxs)
{
quantization_utils::check_concat(args, mins, maxs);
auto quant_type = args[0]->get_element_type();
auto quant_type = args[0].get_element_type();
// output scale
auto min = make_shared<op::Min>(make_shared<op::Concat>(mins, 0), ngraph::AxisSet{0});
auto max = make_shared<op::Max>(make_shared<op::Concat>(maxs, 0), ngraph::AxisSet{0});
auto out_scale = quantization_utils::get_scale(min, max, quant_type);
NodeVector rescaled_args(args.size());
OutputVector rescaled_args(args.size());
for (size_t i = 0; i < args.size(); ++i)
{
auto q_type = args[i]->get_element_type();
auto q_type = args[i].get_element_type();
auto in_scale = make_shared<ngraph::op::Reshape>(
quantization_utils::get_scale(mins[i], maxs[i], q_type),
AxisVector{0},
Shape{});
auto zero = make_constant(q_type, in_scale->get_shape(), 0);
auto zero = make_constant(q_type, in_scale->get_output_shape(0), 0);
rescaled_args[i] =
make_shared<op::Dequantize>(args[i], in_scale, zero, element::f32, AxisSet{});
@ -58,7 +58,7 @@ namespace ngraph
AxisSet{},
op::Quantize::RoundMode::ROUND_NEAREST_TOWARD_EVEN);
}
OutputVector base = as_output_vector(args);
OutputVector base = args;
for (auto node : mins)
{
base.push_back(node);

6
ngraph/src/ngraph/builder/quantized_concat_builder.hpp
View File

@ -32,9 +32,9 @@ namespace ngraph
namespace builder
{
NGRAPH_API
std::shared_ptr<Node> QuantizedConcatBuilder(const NodeVector& args,
std::shared_ptr<Node> QuantizedConcatBuilder(const OutputVector& args,
size_t concatenation_axis,
const NodeVector& mins,
const NodeVector& maxs);
const OutputVector& mins,
const OutputVector& maxs);
}
}

40
ngraph/src/ngraph/builder/split.cpp
View File

@ -47,37 +47,13 @@ namespace
std::make_shared<op::Slice>(output, lower_bounds, upper_bounds)
->add_provenance_group_members_above({output}));
}
/// \brief Return the outputs of the node as vector.
///
/// \param[in] node Node with multiple outputs.
///
/// \return Vector of outputs of input node.
NodeVector get_outputs(const std::shared_ptr<ngraph::Node>& node)
{
const auto outputs_number = node->get_output_size();
ngraph::NodeVector outputs(outputs_number);
for (int i = 0; i < outputs_number; ++i)
{
if (node->output(i).get_node_shared_ptr()->get_output_size() == 1)
{
outputs[i] = node->get_output_as_single_output_node(i);
}
else
{
outputs[i] = std::make_shared<op::GetOutputElement>(node, i);
}
}
return outputs;
}
}
NodeVector builder::split(const Output<ngraph::Node>& value,
const std::vector<size_t>& length_parts,
size_t axis)
OutputVector
builder::split(const Output<Node>& value, const std::vector<size_t>& length_parts, size_t axis)
{
size_t start_index{0};
NodeVector outputs;
OutputVector outputs;
for (const auto& length_part : length_parts)
{
size_t end_index{start_index + length_part};
@ -87,7 +63,7 @@ NodeVector builder::split(const Output<ngraph::Node>& value,
return outputs;
}
NodeVector builder::split(const Output<Node>& value, size_t split_parts, int axis)
OutputVector builder::split(const Output<Node>& value, size_t split_parts, int axis)
{
size_t axis_to_split{static_cast<size_t>(axis)};
if (axis < 0)
@ -100,7 +76,7 @@ NodeVector builder::split(const Output<Node>& value, size_t split_parts, int axi
return split(value, length_parts, axis_to_split);
}
NodeVector builder::opset1::split(const Output<Node>& value,
OutputVector builder::opset1::split(const Output<Node>& value,
const std::vector<size_t>& split_lengths,
int64_t axis)
{
@ -110,13 +86,13 @@ NodeVector builder::opset1::split(const Output<Node>& value,
const auto variadic_split =
std::make_shared<ngraph::opset1::VariadicSplit>(value, axis_node, split_lengths_node);
return get_outputs(variadic_split);
return variadic_split->outputs();
}
NodeVector builder::opset1::split(const Output<Node>& value, size_t num_splits, int64_t axis)
OutputVector builder::opset1::split(const Output<Node>& value, size_t num_splits, int64_t axis)
{
const auto axis_node = ngraph::opset1::Constant::create(element::u64, Shape{}, {axis});
const auto split = std::make_shared<ngraph::opset1::Split>(value, axis_node, num_splits);
return get_outputs(split);
return split->outputs();
}

12
ngraph/src/ngraph/builder/split.hpp
View File

@ -31,7 +31,7 @@ namespace ngraph
///
/// \return The vector containing multiple nodes we split input node into.
///
NodeVector split(const Output<Node>& value,
OutputVector split(const Output<Node>& value,
const std::vector<size_t>& length_parts,
size_t axis = 0);
@ -47,9 +47,9 @@ namespace ngraph
/// indexing). This means that the axis to split on will be counted from
/// the back of the tensor (negative values are subtracted from its rank).
///
/// \return The vector containing multiple nodes we split input node into.
/// \return The vector containing multiple outputs we split input node into.
///
NodeVector split(const Output<Node>& value, size_t split_parts, int axis = 0);
OutputVector split(const Output<Node>& value, size_t split_parts, int axis = 0);
namespace opset1
{
@ -63,11 +63,11 @@ namespace ngraph
/// indexing). This means that the axis to split on will be counted from
/// the back of the tensor (negative values are subtracted from its rank).
///
/// \return The vector containing multiple nodes we split input node into.
/// \return The vector containing multiple outputs we split input node into.
/// The vector is output of Split:v1 op
///
NGRAPH_API
NodeVector split(const Output<Node>& value,
OutputVector split(const Output<Node>& value,
const std::vector<size_t>& split_lengths,
int64_t axis = 0);
@ -88,7 +88,7 @@ namespace ngraph
/// The vector is output of VariadicSplit:v1 op
///
NGRAPH_API
NodeVector split(const Output<Node>& value, size_t num_splits, int64_t axis = 0);
OutputVector split(const Output<Node>& value, size_t num_splits, int64_t axis = 0);
}
} // namespace builder
} // namespace ngraph

22
ngraph/src/ngraph/frontend/onnx_import/core/graph.cpp
View File

@ -157,7 +157,7 @@ namespace ngraph
m_nodes.emplace_back(node_proto, *this);
const Node& node{m_nodes.back()};
NodeVector ng_nodes{node.get_ng_nodes()};
OutputVector ng_nodes{node.get_ng_nodes()};
// Iterate over the number of outputs for given node in graph.
// Some of them may be optional and trimmed. See:
// https://github.com/onnx/onnx/blob/master/docs/IR.md#optional-inputs-and-outputs
@ -174,14 +174,14 @@ namespace ngraph
return m_cache->contains(name);
}
std::shared_ptr<ngraph::Node> Graph::get_ng_node_from_cache(const std::string& name) const
Output<ngraph::Node> Graph::get_ng_node_from_cache(const std::string& name) const
{
return m_cache->get_node(name);
}
NodeVector Graph::get_ng_outputs() const
OutputVector Graph::get_ng_outputs() const
{
NodeVector results;
OutputVector results;
for (const auto& output : m_graph_proto->output())
{
results.emplace_back(get_ng_node_from_cache(output.name()));
@ -189,11 +189,11 @@ namespace ngraph
return results;
}
NodeVector Graph::make_ng_nodes(const Node& onnx_node) const
OutputVector Graph::make_ng_nodes(const Node& onnx_node) const
{
const auto ng_node_factory =
m_model->get_operator(onnx_node.op_type(), onnx_node.domain());
NodeVector ng_node_vector;
OutputVector ng_node_vector;
try
{
ng_node_vector = ng_node_factory(onnx_node);
@ -223,7 +223,7 @@ namespace ngraph
}
void Graph::set_friendly_names(const Node& onnx_node,
const NodeVector& ng_node_vector) const
const OutputVector& ng_node_vector) const
{
for (int i = 0; i < ng_node_vector.size(); ++i)
{
@ -234,7 +234,7 @@ namespace ngraph
break;
}
ng_node_vector[i]->set_friendly_name(onnx_node.output(i));
ng_node_vector[i].get_node()->set_friendly_name(onnx_node.output(i));
}
}
@ -267,7 +267,7 @@ namespace ngraph
}
void Graph::add_provenance_tags(const Node& onnx_node,
const NodeVector& ng_node_vector) const
const OutputVector& ng_node_vector) const
{
if (!ngraph::get_provenance_enabled())
{
@ -278,9 +278,9 @@ namespace ngraph
const auto ng_inputs = onnx_node.get_ng_inputs();
ngraph::traverse_nodes(
ng_node_vector,
as_node_vector(ng_node_vector),
[&tag](std::shared_ptr<ngraph::Node> ng_node) { ng_node->add_provenance_tag(tag); },
ng_inputs);
as_node_vector(ng_inputs));
}
Subgraph::Subgraph(const ONNX_NAMESPACE::GraphProto& proto,

12
ngraph/src/ngraph/frontend/onnx_import/core/graph.hpp
View File

@ -39,12 +39,12 @@ namespace ngraph
const std::vector<Node>& get_nodes() const { return m_nodes; }
const std::vector<ValueInfo>& get_inputs() const { return m_inputs; }
const std::vector<ValueInfo>& get_outputs() const { return m_outputs; }
NodeVector get_ng_outputs() const;
OutputVector get_ng_outputs() const;
const ParameterVector& get_ng_parameters() const { return m_parameters; }
bool is_node_in_cache(const std::string& name) const;
std::shared_ptr<ngraph::Node> get_ng_node_from_cache(const std::string& name) const;
Output<ngraph::Node> get_ng_node_from_cache(const std::string& name) const;
const std::string& get_name() const { return m_graph_proto->name(); }
NodeVector make_ng_nodes(const Node& onnx_node) const;
OutputVector make_ng_nodes(const Node& onnx_node) const;
const GraphCache& get_graph_cache() const;
protected:
@ -52,7 +52,8 @@ namespace ngraph
Model& model,
std::unique_ptr<GraphCache>&& cache);
void set_friendly_names(const Node& onnx_node, const NodeVector& ng_node_vector) const;
void set_friendly_names(const Node& onnx_node,
const OutputVector& ng_node_vector) const;
void add_provenance_tag_to_initializer(
const Tensor& initializer, std::shared_ptr<default_opset::Constant> node) const;
@ -60,7 +61,8 @@ namespace ngraph
void add_provenance_tag_to_input(const ValueInfo& input,
std::shared_ptr<ngraph::Node> node) const;
void add_provenance_tags(const Node& onnx_node, const NodeVector& ng_node_vector) const;
void add_provenance_tags(const Node& onnx_node,
const OutputVector& ng_node_vector) const;
private:
const ONNX_NAMESPACE::GraphProto* m_graph_proto;

6
ngraph/src/ngraph/frontend/onnx_import/core/graph_cache.cpp
View File

@ -21,12 +21,12 @@ namespace ngraph
{
namespace onnx_import
{
void GraphCache::emplace_node(const std::string& name, std::shared_ptr<ngraph::Node>&& node)
void GraphCache::emplace_node(const std::string& name, Output<ngraph::Node>&& node)
{
m_graph_cache_map[name] = std::move(node);
}
std::shared_ptr<ngraph::Node> GraphCache::get_node(const std::string& name) const
Output<ngraph::Node> GraphCache::get_node(const std::string& name) const
{
try
{
@ -52,7 +52,7 @@ namespace ngraph
}
}
std::shared_ptr<ngraph::Node> SubgraphCache::get_node(const std::string& name) const
Output<ngraph::Node> SubgraphCache::get_node(const std::string& name) const
{
// present in subgraph scope
if (GraphCache::contains(name))

8
ngraph/src/ngraph/frontend/onnx_import/core/graph_cache.hpp
View File

@ -35,7 +35,7 @@ namespace ngraph
///
/// \param[in] name The name of node added to the cache.
/// \param[in] node The node added to the cache.
void emplace_node(const std::string& name, std::shared_ptr<ngraph::Node>&& node);
void emplace_node(const std::string& name, Output<ngraph::Node>&& node);
/// \brief Get the node from the cache
///
@ -44,7 +44,7 @@ namespace ngraph
/// \param[in] name The name of the node.
///
/// \return The node named `name`.
virtual std::shared_ptr<ngraph::Node> get_node(const std::string& name) const;
virtual Output<ngraph::Node> get_node(const std::string& name) const;
/// \brief Return true if the node named `name` exist in the cache.
///
@ -54,7 +54,7 @@ namespace ngraph
virtual bool contains(const std::string& name) const;
private:
std::map<std::string, std::shared_ptr<ngraph::Node>> m_graph_cache_map;
std::map<std::string, Output<ngraph::Node>> m_graph_cache_map;
};
class SubgraphCache : public GraphCache
@ -72,7 +72,7 @@ namespace ngraph
/// \param[in] name The name of the node.
///
/// \return The node named `name` from subgraph (as present) or from parent graph.
std::shared_ptr<ngraph::Node> get_node(const std::string& name) const override;
Output<ngraph::Node> get_node(const std::string& name) const override;
/// \brief Return true if the node named `name` exist in the cache.
///

16
ngraph/src/ngraph/frontend/onnx_import/core/node.cpp
View File

@ -40,8 +40,8 @@ namespace ngraph
}
const std::vector<Attribute>& attributes() const;
NodeVector get_ng_nodes(const Node& node) const;
NodeVector get_ng_inputs() const;
OutputVector get_ng_nodes(const Node& node) const;
OutputVector get_ng_inputs() const;
const std::string& domain() const;
const std::string& op_type() const;
@ -140,14 +140,14 @@ namespace ngraph
return it->get_subgraph(graph());
}
NodeVector Node::Impl::get_ng_nodes(const Node& node) const
OutputVector Node::Impl::get_ng_nodes(const Node& node) const
{
return m_graph->make_ng_nodes(node);
}
NodeVector Node::Impl::get_ng_inputs() const
OutputVector Node::Impl::get_ng_inputs() const
{
NodeVector result;
OutputVector result;
for (const auto& name : m_node_proto->input())
{
if (!name.empty())
@ -156,7 +156,7 @@ namespace ngraph
}
else
{
result.push_back(std::make_shared<NullNode>());
result.push_back(std::make_shared<NullNode>()->output(0));
}
}
return result;
@ -197,8 +197,8 @@ namespace ngraph
{
}
NodeVector Node::get_ng_inputs() const { return m_pimpl->get_ng_inputs(); }
NodeVector Node::get_ng_nodes() const { return m_pimpl->get_ng_nodes(*this); }
OutputVector Node::get_ng_inputs() const { return m_pimpl->get_ng_inputs(); }
OutputVector Node::get_ng_nodes() const { return m_pimpl->get_ng_nodes(*this); }
const std::string& Node::domain() const { return m_pimpl->domain(); }
const std::string& Node::op_type() const { return m_pimpl->op_type(); }
const std::string& Node::get_description() const { return m_pimpl->description(); }

4
ngraph/src/ngraph/frontend/onnx_import/core/node.hpp
View File

@ -64,8 +64,8 @@ namespace ngraph
Node& operator=(Node&&) noexcept = delete;
Node& operator=(const Node&) = delete;
NodeVector get_ng_inputs() const;
NodeVector get_ng_nodes() const;
OutputVector get_ng_inputs() const;
OutputVector get_ng_nodes() const;
const std::string& domain() const;
const std::string& op_type() const;
const std::string& get_name() const;

5
ngraph/src/ngraph/frontend/onnx_import/core/null_node.cpp
View File

@ -42,3 +42,8 @@ bool ngraph::op::is_null(const std::shared_ptr<ngraph::Node>& node)
{
return is_null(node.get());
}
bool ngraph::op::is_null(const Output<ngraph::Node>& output)
{
return is_null(output.get_node());
}

2
ngraph/src/ngraph/frontend/onnx_import/core/null_node.hpp
View File

@ -29,6 +29,8 @@ namespace ngraph
bool is_null(const ngraph::Node* node);
ONNX_IMPORTER_API
bool is_null(const std::shared_ptr<ngraph::Node>& node);
ONNX_IMPORTER_API
bool is_null(const Output<ngraph::Node>& output);
}
namespace onnx_import
{

2
ngraph/src/ngraph/frontend/onnx_import/core/operator_set.hpp
View File

@ -28,7 +28,7 @@ namespace ngraph
namespace onnx_import
{
/// \brief Function which transforms single ONNX operator to nGraph sub-graph.
using Operator = std::function<NodeVector(const Node&)>;
using Operator = std::function<OutputVector(const Node&)>;
/// \brief Map which contains ONNX operators accessible by std::string value as a key.
using OperatorSet = std::unordered_map<std::string, std::reference_wrapper<const Operator>>;

2
ngraph/src/ngraph/frontend/onnx_import/op/abs.hpp
View File

@ -30,7 +30,7 @@ namespace ngraph
{
namespace set_1
{
inline NodeVector abs(const Node& node)
inline OutputVector abs(const Node& node)
{
return {std::make_shared<default_opset::Abs>(node.get_ng_inputs().at(0))};
}

2
ngraph/src/ngraph/frontend/onnx_import/op/acos.hpp
View File

@ -30,7 +30,7 @@ namespace ngraph
{
namespace set_1
{
inline NodeVector acos(const Node& node)
inline OutputVector acos(const Node& node)
{
return {std::make_shared<default_opset::Acos>(node.get_ng_inputs().at(0))};
}

2
ngraph/src/ngraph/frontend/onnx_import/op/acosh.hpp
View File

@ -28,7 +28,7 @@ namespace ngraph
{
namespace set_1
{
inline NodeVector acosh(const Node& node)
inline OutputVector acosh(const Node& node)
{
return {std::make_shared<default_opset::Acosh>(node.get_ng_inputs().at(0))};
}

4
ngraph/src/ngraph/frontend/onnx_import/op/add.cpp
View File

@ -27,7 +27,7 @@ namespace ngraph
{
namespace set_1
{
NodeVector add(const Node& node)
OutputVector add(const Node& node)
{
const Output<ngraph::Node> lhs_node = node.get_ng_inputs().at(0);
Output<ngraph::Node> rhs_node = node.get_ng_inputs().at(1);
@ -45,7 +45,7 @@ namespace ngraph
namespace set_7
{
NodeVector add(const Node& node)
OutputVector add(const Node& node)
{
return {std::make_shared<default_opset::Add>(node.get_ng_inputs().at(0),
node.get_ng_inputs().at(1))};

4
ngraph/src/ngraph/frontend/onnx_import/op/add.hpp
View File

@ -29,13 +29,13 @@ namespace ngraph
{
namespace set_1
{
NodeVector add(const Node& node);
OutputVector add(const Node& node);
} // namespace set_1
namespace set_7
{
NodeVector add(const Node& node);
OutputVector add(const Node& node);
} // namespace set_7

2
ngraph/src/ngraph/frontend/onnx_import/op/and.hpp
View File

@ -31,7 +31,7 @@ namespace ngraph
{
namespace set_1
{
inline NodeVector logical_and(const Node& node)
inline OutputVector logical_and(const Node& node)
{
return {std::make_shared<default_opset::LogicalAnd>(
node.get_ng_inputs().at(0), node.get_ng_inputs().at(1))};

2
ngraph/src/ngraph/frontend/onnx_import/op/argmax.cpp
View File

@ -25,7 +25,7 @@ namespace ngraph
{
namespace set_1
{
NodeVector argmax(const Node& node)
OutputVector argmax(const Node& node)
{
const utils::ArgMinMaxFactory arg_factory(node);
return {arg_factory.make_arg_max()};

2
ngraph/src/ngraph/frontend/onnx_import/op/argmax.hpp
View File

@ -33,7 +33,7 @@ namespace ngraph
///
/// \return The vector containing an Ngraph node which produces the output
/// of an ONNX ArgMax operation.
NodeVector argmax(const Node& node);
OutputVector argmax(const Node& node);
} // namespace set_1

2
ngraph/src/ngraph/frontend/onnx_import/op/argmin.cpp
View File

@ -25,7 +25,7 @@ namespace ngraph
{
namespace set_1
{
NodeVector argmin(const Node& node)
OutputVector argmin(const Node& node)
{
const utils::ArgMinMaxFactory arg_factory(node);
return {arg_factory.make_arg_min()};

2
ngraph/src/ngraph/frontend/onnx_import/op/argmin.hpp
View File

@ -33,7 +33,7 @@ namespace ngraph
///
/// \return The vector containing an Ngraph node which produces the output
/// of an ONNX ArgMin operation.
NodeVector argmin(const Node& node);
OutputVector argmin(const Node& node);
} // namespace set_1

2
ngraph/src/ngraph/frontend/onnx_import/op/asin.hpp
View File

@ -31,7 +31,7 @@ namespace ngraph
{
namespace set_1
{
inline NodeVector asin(const Node& node)
inline OutputVector asin(const Node& node)
{
return {std::make_shared<default_opset::Asin>(node.get_ng_inputs().at(0))};
}

2
ngraph/src/ngraph/frontend/onnx_import/op/asinh.hpp
View File

@ -28,7 +28,7 @@ namespace ngraph
{
namespace set_1
{
inline NodeVector asinh(const Node& node)
inline OutputVector asinh(const Node& node)
{
return {std::make_shared<default_opset::Asinh>(node.get_ng_inputs().at(0))};
}

2
ngraph/src/ngraph/frontend/onnx_import/op/atan.hpp
View File

@ -30,7 +30,7 @@ namespace ngraph
{
namespace set_1
{
inline NodeVector atan(const Node& node)
inline OutputVector atan(const Node& node)
{
return {std::make_shared<default_opset::Atan>(node.get_ng_inputs().at(0))};
}

2
ngraph/src/ngraph/frontend/onnx_import/op/atanh.hpp
View File

@ -28,7 +28,7 @@ namespace ngraph
{
namespace set_1
{
inline NodeVector atanh(const Node& node)
inline OutputVector atanh(const Node& node)
{
return {std::make_shared<default_opset::Atanh>(node.get_ng_inputs().at(0))};
}

2
ngraph/src/ngraph/frontend/onnx_import/op/average_pool.cpp
View File

@ -26,7 +26,7 @@ namespace ngraph
{
namespace set_1
{
NodeVector average_pool(const Node& node)
OutputVector average_pool(const Node& node)
{
return pooling::LocalPoolingFactory(node).make_avg_pool();
}

2
ngraph/src/ngraph/frontend/onnx_import/op/average_pool.hpp
View File

@ -33,7 +33,7 @@ namespace ngraph
///
/// \return The vector containing Ngraph nodes producing output of ONNX AveragePool
/// operation.
NodeVector average_pool(const Node& node);
OutputVector average_pool(const Node& node);
} // namespace set_1

8
ngraph/src/ngraph/frontend/onnx_import/op/batch_norm.cpp
View File

@ -30,14 +30,14 @@ namespace ngraph
{
namespace set_1
{
NodeVector batch_norm(const Node& node)
OutputVector batch_norm(const Node& node)
{
NodeVector inputs{node.get_ng_inputs()};
OutputVector inputs{node.get_ng_inputs()};
auto x = inputs.at(0);
auto scale = inputs.at(1);
auto bias = inputs.at(2);
std::shared_ptr<ngraph::Node> mean{nullptr};
std::shared_ptr<ngraph::Node> var{nullptr};
Output<ngraph::Node> mean;
Output<ngraph::Node> var;
std::int64_t is_test{node.get_attribute_value<std::int64_t>("is_test", 1)};
double epsilon{node.get_attribute_value<double>("epsilon", 1e-5)};

2
ngraph/src/ngraph/frontend/onnx_import/op/batch_norm.hpp
View File

@ -27,7 +27,7 @@ namespace ngraph
{
namespace set_1
{
NodeVector batch_norm(const Node& node);
OutputVector batch_norm(const Node& node);
} // namespace set_1

2
ngraph/src/ngraph/frontend/onnx_import/op/cast.cpp
View File

@ -28,7 +28,7 @@ namespace ngraph
{
namespace set_1
{
NodeVector cast(const Node& node)
OutputVector cast(const Node& node)
{
auto data = node.get_ng_inputs().at(0);
int64_t target_type = node.get_attribute_value<int64_t>("to");

2
ngraph/src/ngraph/frontend/onnx_import/op/cast.hpp
View File

@ -27,7 +27,7 @@ namespace ngraph
{
namespace set_1
{
NodeVector cast(const Node& node);
OutputVector cast(const Node& node);
} // namespace set_1

2
ngraph/src/ngraph/frontend/onnx_import/op/ceil.hpp
View File

@ -30,7 +30,7 @@ namespace ngraph
{
namespace set_1
{
inline NodeVector ceil(const Node& node)
inline OutputVector ceil(const Node& node)
{
return {std::make_shared<default_opset::Ceiling>(node.get_ng_inputs().at(0))};
}

16
ngraph/src/ngraph/frontend/onnx_import/op/clip.cpp
View File

@ -30,7 +30,7 @@ namespace ngraph
{
namespace set_1
{
NodeVector clip(const Node& node)
OutputVector clip(const Node& node)
{
const auto data = node.get_ng_inputs().at(0);
@ -47,14 +47,14 @@ namespace ngraph
namespace set_11
{
NodeVector clip(const Node& node)
OutputVector clip(const Node& node)
{
const NodeVector inputs{node.get_ng_inputs()};
const std::shared_ptr<ngraph::Node> data = inputs.at(0);
const element::Type data_type = data->get_element_type();
const Shape data_shape = data->get_shape();
std::shared_ptr<ngraph::Node> min;
std::shared_ptr<ngraph::Node> max;
const OutputVector inputs{node.get_ng_inputs()};
const Output<ngraph::Node> data = inputs.at(0);
const element::Type data_type = data.get_element_type();
const Shape data_shape = data.get_shape();
Output<ngraph::Node> min;
Output<ngraph::Node> max;
// If second input is provided, assign to min input, otherwise set lowest
// numeric limit of double as min input.

4
ngraph/src/ngraph/frontend/onnx_import/op/clip.hpp
View File

@ -27,13 +27,13 @@ namespace ngraph
{
namespace set_1
{
NodeVector clip(const Node& node);
OutputVector clip(const Node& node);
} // namespace set_1
namespace set_11
{
NodeVector clip(const Node& node);
OutputVector clip(const Node& node);
} // namespace set_11

4
ngraph/src/ngraph/frontend/onnx_import/op/concat.cpp
View File

@ -30,9 +30,9 @@ namespace ngraph
{
namespace set_1
{
NodeVector concat(const Node& node)
OutputVector concat(const Node& node)
{
NodeVector inputs{node.get_ng_inputs()};
OutputVector inputs{node.get_ng_inputs()};
std::int64_t axis = node.get_attribute_value<std::int64_t>("axis");
return {std::make_shared<default_opset::Concat>(inputs, axis)};
}

2
ngraph/src/ngraph/frontend/onnx_import/op/concat.hpp
View File

@ -27,7 +27,7 @@ namespace ngraph
{
namespace set_1
{
NodeVector concat(const Node& node);
OutputVector concat(const Node& node);
} // namespace set_1

2
ngraph/src/ngraph/frontend/onnx_import/op/constant.cpp
View File

@ -153,7 +153,7 @@ namespace ngraph
}
}
NodeVector constant(const onnx_import::Node& node)
OutputVector constant(const onnx_import::Node& node)
{
return {make_constant(node.get_attribute_value<Tensor>("value"))};
}

2
ngraph/src/ngraph/frontend/onnx_import/op/constant.hpp
View File

@ -27,7 +27,7 @@ namespace ngraph
{
namespace set_1
{
NodeVector constant(const Node& node);
OutputVector constant(const Node& node);
} // namespace set_1

4
ngraph/src/ngraph/frontend/onnx_import/op/constant_of_shape.cpp
View File

@ -28,9 +28,9 @@ namespace ngraph
{
namespace set_1
{
NodeVector constant_of_shape(const onnx_import::Node& node)
OutputVector constant_of_shape(const onnx_import::Node& node)
{
std::shared_ptr<ngraph::Node> constant_value;
Output<ngraph::Node> constant_value;
if (node.has_attribute("value"))
{
auto value_tensor = node.get_attribute_value<Tensor>("value");

2
ngraph/src/ngraph/frontend/onnx_import/op/constant_of_shape.hpp
View File

@ -27,7 +27,7 @@ namespace ngraph
{
namespace set_1
{
NodeVector constant_of_shape(const Node& node);
OutputVector constant_of_shape(const Node& node);
} // namespace set_1

24
ngraph/src/ngraph/frontend/onnx_import/op/conv.cpp
View File

@ -38,8 +38,8 @@ namespace ngraph
namespace
{
std::shared_ptr<ngraph::op::Op>
make_ng_convolution(const std::shared_ptr<ngraph::Node>& data,
const std::shared_ptr<ngraph::Node>& filters,
make_ng_convolution(const Output<ngraph::Node>& data,
const Output<ngraph::Node>& filters,
const ngraph::Strides& strides,
const ngraph::Strides& dilations,
const ngraph::CoordinateDiff& padding_below,
@ -49,7 +49,7 @@ namespace ngraph
{
if (groups > 1)
{
auto filters_shape = filters->get_shape();
auto filters_shape = filters.get_shape();
filters_shape.at(0) = filters_shape.at(0) / groups;
filters_shape.insert(filters_shape.begin(), groups);
@ -77,18 +77,16 @@ namespace ngraph
}
}
std::shared_ptr<ngraph::Node>
add_bias(const std::shared_ptr<ngraph::Node>& ng_conv,
const std::shared_ptr<ngraph::Node>& bias)
std::shared_ptr<ngraph::Node> add_bias(const Output<ngraph::Node>& ng_conv,
const Output<ngraph::Node>& bias)
{
const auto rank_of_conv =
ng_conv->get_output_partial_shape(0).rank().get_length();
const auto rank_of_conv = ng_conv.get_partial_shape().rank().get_length();
// reshape the bias node {M} to {1, M, 1, 1, ..., 1}
// this is required by the addition operation that needs to be able
// to broadcast the bias to match the shape of the convolution node
std::vector<size_t> reshape_pattern_values(rank_of_conv, 1U);
reshape_pattern_values[1] = bias->get_shape().front();
reshape_pattern_values[1] = bias.get_shape().front();
const auto reshape_pattern =
default_opset::Constant::create(element::u64,
Shape{reshape_pattern_values.size()},
@ -101,16 +99,16 @@ namespace ngraph
}
} // namespace
NodeVector conv(const Node& node)
OutputVector conv(const Node& node)
{
// in the current implementation we assume that the data input rank is static
// and only the 'batch' dimension can be dynamic
const NodeVector& inputs = node.get_ng_inputs();
const OutputVector& inputs = node.get_ng_inputs();
const auto data = inputs.at(0);
const auto filters = inputs.at(1);
const auto groups = node.get_attribute_value<int64_t>("group", 1);
NGRAPH_CHECK(data->get_output_partial_shape(0).rank().is_static(),
NGRAPH_CHECK(data.get_partial_shape().rank().is_static(),
"The input data tensor's rank has to be known (static)");
const auto strides = convpool::get_strides(node);
@ -137,7 +135,7 @@ namespace ngraph
else
{
const auto bias = inputs.at(2);
const auto bias_ps = bias->get_output_partial_shape(0);
const auto bias_ps = bias.get_partial_shape();
NGRAPH_CHECK(bias_ps.is_static() && is_vector(bias_ps.to_shape()),
"The bias input needs to be a static 1D vector");

2
ngraph/src/ngraph/frontend/onnx_import/op/conv.hpp
View File

@ -33,7 +33,7 @@ namespace ngraph
///
/// \return The vector containing Ngraph nodes producing output of ONNX convolution
/// operation.
NodeVector conv(const Node& node);
OutputVector conv(const Node& node);
} // namespace set_1

18
ngraph/src/ngraph/frontend/onnx_import/op/conv_integer.cpp
View File

@ -14,6 +14,9 @@
// limitations under the License.
//*****************************************************************************
// Disabled in CMakeList
// Update to higher opset required
#include "conv_integer.hpp"
#include "exceptions.hpp"
#include "ngraph/builder/make_constant.hpp"
@ -31,9 +34,9 @@ namespace ngraph
{
namespace set_1
{
NodeVector conv_integer(const Node& node)
OutputVector conv_integer(const Node& node)
{
const NodeVector& inputs = node.get_ng_inputs();
const OutputVector& inputs = node.get_ng_inputs();
auto num_inputs = inputs.size();
auto input = inputs.at(0);
auto filters = inputs.at(1);
@ -51,19 +54,18 @@ namespace ngraph
ngraph::op::PadType auto_pad_type = convpool::get_auto_pad(node);
auto& padding_below = paddings.first;
auto& padding_above = paddings.second;
convpool::calculate_auto_pads(input->get_shape(),
filters->get_shape(),
convpool::calculate_auto_pads(input.get_shape(),
filters.get_shape(),
window_movement_strides,
window_dilation_strides,
auto_pad_type,
padding_below,
padding_above);
const Strides default_data_dilation_strides(input->get_shape().size() - 2, 1);
const Strides default_data_dilation_strides(input.get_shape().size() - 2, 1);
auto scale_one = make_constant(ngraph::element::f32, Shape{}, 1);
auto input_zero_point = make_constant(input->get_element_type(), Shape{}, 0);
auto filters_zero_point =
make_constant(filters->get_element_type(), Shape{}, 0);
auto input_zero_point = make_constant(input.get_element_type(), Shape{}, 0);
auto filters_zero_point = make_constant(filters.get_element_type(), Shape{}, 0);
auto output_zero_point = make_constant(ngraph::element::i32, Shape{}, 0);
if (num_inputs == 2)

5
ngraph/src/ngraph/frontend/onnx_import/op/conv_integer.hpp
View File

@ -14,6 +14,9 @@
// limitations under the License.
//*****************************************************************************
// Disabled in CMakeList
// Update to higher opset required
#pragma once
#include "core/node.hpp"
@ -33,7 +36,7 @@ namespace ngraph
///
/// \return The vector containing Ngraph nodes producing output of quantized ONNX
/// convolution operation.
NodeVector conv_integer(const Node& node);
OutputVector conv_integer(const Node& node);
} // namespace set_1

32
ngraph/src/ngraph/frontend/onnx_import/op/conv_transpose.cpp
View File

@ -44,9 +44,9 @@ namespace ngraph
{
namespace
{
std::shared_ptr<ngraph::Node>
make_group_conv_backprop(const std::shared_ptr<ngraph::Node>& data,
const std::shared_ptr<ngraph::Node>& filters,
Output<ngraph::Node>
make_group_conv_backprop(const Output<ngraph::Node>& data,
const Output<ngraph::Node>& filters,
const Strides& strides,
const Strides& dilations,
const CoordinateDiff& pads_begin,
@ -83,9 +83,9 @@ namespace ngraph
}
}
std::shared_ptr<ngraph::Node>
make_conv_backprop(const std::shared_ptr<ngraph::Node>& data,
const std::shared_ptr<ngraph::Node>& filters,
Output<ngraph::Node>
make_conv_backprop(const Output<ngraph::Node>& data,
const Output<ngraph::Node>& filters,
const Strides& strides,
const Strides& dilations,
const CoordinateDiff& pads_begin,
@ -124,8 +124,7 @@ namespace ngraph
}
}
std::shared_ptr<ngraph::Node>
get_reshaped_filters(const std::shared_ptr<ngraph::Node>& filters,
Output<ngraph::Node> get_reshaped_filters(const Output<ngraph::Node>& filters,
const PartialShape& filters_pshape,
int64_t groups)
{
@ -180,12 +179,11 @@ namespace ngraph
}
}
std::shared_ptr<ngraph::Node>
get_prepared_bias(const std::shared_ptr<ngraph::Node>& bias,
const std::shared_ptr<ngraph::Node>& conv)
Output<ngraph::Node> get_prepared_bias(const Output<ngraph::Node>& bias,
const Output<ngraph::Node>& conv)
{
// Prepare bias shape [1, C, 1, 1]
const auto& conv_pshape = conv->get_output_partial_shape(0);
const auto& conv_pshape = conv.get_partial_shape();
std::shared_ptr<ngraph::Node> bias_shape_node;
if (conv_pshape.rank().is_static() && conv_pshape[1].is_static())
@ -231,9 +229,9 @@ namespace ngraph
}
}
NodeVector conv_transpose(const Node& node)
OutputVector conv_transpose(const Node& node)
{
const NodeVector& inputs = node.get_ng_inputs();
const OutputVector& inputs = node.get_ng_inputs();
CHECK_VALID_NODE(node,
inputs.size() == 2 || inputs.size() == 3,
@ -243,8 +241,8 @@ namespace ngraph
auto data = inputs[0];
auto filters = inputs[1];
const auto& data_pshape = data->get_output_partial_shape(0);
const auto& filters_pshape = filters->get_output_partial_shape(0);
const auto& data_pshape = data.get_partial_shape();
const auto& filters_pshape = filters.get_partial_shape();
std::size_t num_spatial_dims = 0;
Strides strides, dilations;
@ -291,7 +289,7 @@ namespace ngraph
CHECK_VALID_NODE(
node, groups >= 0, "Incorrect value of 'group' attribute: ", groups);
std::shared_ptr<ngraph::Node> conv_node;
Output<ngraph::Node> conv_node;
// reshape filters to match desired shape:
// [GROUPS, C_INPUT, C_OUTPUT, K_D, ..., K_1]

2
ngraph/src/ngraph/frontend/onnx_import/op/conv_transpose.hpp
View File

@ -33,7 +33,7 @@ namespace ngraph
///
/// \return The vector containing Ngraph nodes producing output of ONNX convolution
/// operation.
NodeVector conv_transpose(const Node& node);
OutputVector conv_transpose(const Node& node);
} // namespace set_1

2
ngraph/src/ngraph/frontend/onnx_import/op/cos.cpp
View File

@ -27,7 +27,7 @@ namespace ngraph
{
namespace set_1
{
NodeVector cos(const Node& node)
OutputVector cos(const Node& node)
{
return {std::make_shared<default_opset::Cos>(node.get_ng_inputs().at(0))};
}

2
ngraph/src/ngraph/frontend/onnx_import/op/cos.hpp
View File

@ -27,7 +27,7 @@ namespace ngraph
{
namespace set_1
{
NodeVector cos(const Node& node);
OutputVector cos(const Node& node);
}
}

2
ngraph/src/ngraph/frontend/onnx_import/op/cosh.cpp
View File

@ -27,7 +27,7 @@ namespace ngraph
{
namespace set_1
{
NodeVector cosh(const Node& node)
OutputVector cosh(const Node& node)
{
return {std::make_shared<default_opset::Cosh>(node.get_ng_inputs().at(0))};
}

2
ngraph/src/ngraph/frontend/onnx_import/op/cosh.hpp
View File

@ -27,7 +27,7 @@ namespace ngraph
{
namespace set_1
{
NodeVector cosh(const Node& node);
OutputVector cosh(const Node& node);
}
}
} // namespace onnx_import

6
ngraph/src/ngraph/frontend/onnx_import/op/cum_sum.cpp
View File

@ -27,13 +27,13 @@ namespace ngraph
{
namespace set_1
{
NodeVector cum_sum(const Node& node)
OutputVector cum_sum(const Node& node)
{
auto inputs = node.get_ng_inputs();
auto data = inputs.at(0);
bool exclusive = node.get_attribute_value<std::int64_t>("exclusive", 0);
bool reverse = node.get_attribute_value<std::int64_t>("reverse", 0);
std::shared_ptr<ngraph::Node> axis;
Output<ngraph::Node> axis;
if (inputs.size() > 1)
{
@ -44,7 +44,7 @@ namespace ngraph
axis =
default_opset::Constant::create(element::i64, Shape{}, {0}); // default
}
return NodeVector{
return OutputVector{
std::make_shared<default_opset::CumSum>(data, axis, exclusive, reverse)};
}

2
ngraph/src/ngraph/frontend/onnx_import/op/cum_sum.hpp
View File

@ -27,7 +27,7 @@ namespace ngraph
{
namespace set_1
{
NodeVector cum_sum(const Node& node);
OutputVector cum_sum(const Node& node);
} // namespace set_1

4
ngraph/src/ngraph/frontend/onnx_import/op/depth_to_space.cpp
View File

@ -25,7 +25,7 @@ namespace ngraph
{
namespace set_1
{
NodeVector depth_to_space(const Node& node)
OutputVector depth_to_space(const Node& node)
{
auto data = node.get_ng_inputs().at(0);
const auto mode = node.get_attribute_value<std::string>("mode", "DCR");
@ -34,7 +34,7 @@ namespace ngraph
? default_opset::DepthToSpace::DepthToSpaceMode::BLOCKS_FIRST
: default_opset::DepthToSpace::DepthToSpaceMode::DEPTH_FIRST;
const auto block_size = node.get_attribute_value<std::int64_t>("blocksize");
return NodeVector{std::make_shared<default_opset::DepthToSpace>(
return OutputVector{std::make_shared<default_opset::DepthToSpace>(
data, ngraph_mode, block_size)};
}
} // namespace set_1

4
ngraph/src/ngraph/frontend/onnx_import/op/depth_to_space.hpp
View File

@ -34,9 +34,9 @@ namespace ngraph
///
/// \param[in] node The ONNX input node describing operation.
///
/// \return NodeVector containing Tensor with shape:
/// \return OutputVector containing Tensor with shape:
/// [N, C/(blocksize * blocksize), H * blocksize, W * blocksize]
NodeVector depth_to_space(const Node& node);
OutputVector depth_to_space(const Node& node);
} // namespace set_1
} // namespace op

38
ngraph/src/ngraph/frontend/onnx_import/op/dequantize_linear.cpp
View File

@ -36,13 +36,13 @@ namespace ngraph
{
namespace
{
std::shared_ptr<ngraph::Node> get_zero_point(const NodeVector& inputs)
Output<ngraph::Node> get_zero_point(const OutputVector& inputs)
{
if (inputs.size() == 3 && !ngraph::op::is_null(inputs[2]))
{
auto zero_point = inputs[2];
if (zero_point->get_element_type() != element::f32)
if (zero_point.get_element_type() != element::f32)
{
zero_point =
std::make_shared<default_opset::Convert>(zero_point, element::f32);
@ -58,9 +58,9 @@ namespace ngraph
}
namespace set_1
{
NodeVector dequantize_linear(const Node& node)
OutputVector dequantize_linear(const Node& node)
{
const NodeVector inputs{node.get_ng_inputs()};
const OutputVector inputs{node.get_ng_inputs()};
NGRAPH_CHECK(
2 <= inputs.size() && inputs.size() <= 3,
@ -71,8 +71,9 @@ namespace ngraph
const auto scale = inputs[1];
const auto zero_point = get_zero_point(inputs);
common::validate_scalar_input("Dequantization scale", scale, {element::f32});
common::validate_scalar_input("Zero point", zero_point);
common::validate_scalar_input(
"Dequantization scale", scale.get_node_shared_ptr(), {element::f32});
common::validate_scalar_input("Zero point", zero_point.get_node_shared_ptr());
const auto converted_x =
std::make_shared<default_opset::Convert>(x, element::f32);
@ -86,11 +87,11 @@ namespace ngraph
{
namespace
{
void validate_scale(const std::shared_ptr<ngraph::Node> scale,
const std::shared_ptr<ngraph::Node> x,
void validate_scale(const Output<ngraph::Node> scale,
const Output<ngraph::Node> x,
const int64_t axis)
{
const auto& scale_shape = scale->get_output_partial_shape(0);
const auto& scale_shape = scale.get_partial_shape();
NGRAPH_CHECK(scale_shape.rank().get_length() == 0 ||
scale_shape.rank().get_length() == 1,
"Dequantization scale needs to be a scalar or a vector.");
@ -98,7 +99,7 @@ namespace ngraph
if (scale_shape.rank().get_length() == 1)
{
const auto& scale_dim = scale_shape[0];
const auto& x_shape = x->get_output_partial_shape(0);
const auto& x_shape = x.get_partial_shape();
const auto& x_dim_at_axis = x_shape[axis];
NGRAPH_CHECK(scale_dim.same_scheme(x_dim_at_axis),
@ -111,11 +112,11 @@ namespace ngraph
}
}
void validate_zero_point(const std::shared_ptr<ngraph::Node> zero_point,
const std::shared_ptr<ngraph::Node> x,
void validate_zero_point(const Output<ngraph::Node> zero_point,
const Output<ngraph::Node> x,
const int64_t axis)
{
const auto& zero_point_shape = zero_point->get_output_partial_shape(0);
const auto& zero_point_shape = zero_point.get_partial_shape();
NGRAPH_CHECK(zero_point_shape.rank().get_length() == 0 ||
zero_point_shape.rank().get_length() == 1,
"Zero point needs to be a scalar or a vector.");
@ -123,7 +124,7 @@ namespace ngraph
if (zero_point_shape.rank().get_length() == 1)
{
const auto& zero_point_dim = zero_point_shape[0];
const auto& x_shape = x->get_output_partial_shape(0);
const auto& x_shape = x.get_partial_shape();
const auto& x_dim_at_axis = x_shape[axis];
NGRAPH_CHECK(zero_point_dim.same_scheme(x_dim_at_axis),
@ -136,8 +137,7 @@ namespace ngraph
}
}
std::shared_ptr<ngraph::Node>
reshape_input(const std::shared_ptr<ngraph::Node> input,
std::shared_ptr<ngraph::Node> reshape_input(const Output<ngraph::Node> input,
const int64_t axis,
const PartialShape& x_shape)
{
@ -170,9 +170,9 @@ namespace ngraph
}
}
NodeVector dequantize_linear(const Node& node)
OutputVector dequantize_linear(const Node& node)
{
const NodeVector inputs{node.get_ng_inputs()};
const OutputVector inputs{node.get_ng_inputs()};
NGRAPH_CHECK(2 <= inputs.size() && inputs.size() <= 3,
"The DequantizeLinear op expects 2 required and one optional "
@ -183,7 +183,7 @@ namespace ngraph
auto scale = inputs[1];
auto zero_point = get_zero_point(inputs);
const auto x_shape = x->get_output_partial_shape(0);
const auto x_shape = x.get_partial_shape();
NGRAPH_CHECK(x_shape.rank().is_static(),
"Rank of the input data tensor has to be known (static).");

4
ngraph/src/ngraph/frontend/onnx_import/op/dequantize_linear.hpp
View File

@ -27,13 +27,13 @@ namespace ngraph
{
namespace set_1
{
NodeVector dequantize_linear(const Node& node);
OutputVector dequantize_linear(const Node& node);
} // namespace set_1
namespace set_13
{
NodeVector dequantize_linear(const Node& node);
OutputVector dequantize_linear(const Node& node);
}
} // namespace op

4
ngraph/src/ngraph/frontend/onnx_import/op/div.hpp
View File

@ -32,7 +32,7 @@ namespace ngraph
{
namespace set_1
{
inline NodeVector div(const Node& node)
inline OutputVector div(const Node& node)
{
const Output<ngraph::Node> lhs_node = node.get_ng_inputs().at(0);
Output<ngraph::Node> rhs_node = node.get_ng_inputs().at(1);
@ -50,7 +50,7 @@ namespace ngraph
namespace set_7
{
inline NodeVector div(const Node& node)
inline OutputVector div(const Node& node)
{
return {std::make_shared<default_opset::Divide>(node.get_ng_inputs().at(0),
node.get_ng_inputs().at(1))};

5
ngraph/src/ngraph/frontend/onnx_import/op/dropout.hpp
View File

@ -30,11 +30,12 @@ namespace ngraph
{
namespace set_1
{
inline NodeVector dropout(const Node& node)
inline OutputVector dropout(const Node& node)
{
// First value is actual output of Dropout,
// the second one is just a placeholder for optional trailing output.
return {node.get_ng_inputs().at(0), std::make_shared<NullNode>()};
return {node.get_ng_inputs().at(0).get_node_shared_ptr(),
std::make_shared<NullNode>()};
}
} // namespace set_1

4
ngraph/src/ngraph/frontend/onnx_import/op/elu.cpp
View File

@ -28,12 +28,12 @@ namespace ngraph
{
namespace set_1
{
NodeVector elu(const Node& node)
OutputVector elu(const Node& node)
{
auto data = node.get_ng_inputs().at(0);
double alpha = node.get_attribute_value<double>("alpha", 1);
return NodeVector{std::make_shared<default_opset::Elu>(data, alpha)};
return OutputVector{std::make_shared<default_opset::Elu>(data, alpha)};
}
} // namespace set_1

2
ngraph/src/ngraph/frontend/onnx_import/op/elu.hpp
View File

@ -27,7 +27,7 @@ namespace ngraph
{
namespace set_1
{
NodeVector elu(const Node& node);
OutputVector elu(const Node& node);
} // namespace set_1

2
ngraph/src/ngraph/frontend/onnx_import/op/equal.hpp
View File

@ -30,7 +30,7 @@ namespace ngraph
{
namespace set_1
{
inline NodeVector equal(const Node& node)
inline OutputVector equal(const Node& node)
{
return {std::make_shared<default_opset::Equal>(node.get_ng_inputs().at(0),
node.get_ng_inputs().at(1))};

2
ngraph/src/ngraph/frontend/onnx_import/op/erf.hpp
View File

@ -30,7 +30,7 @@ namespace ngraph
{
namespace set_1
{
inline NodeVector erf(const Node& node)
inline OutputVector erf(const Node& node)
{
return {std::make_shared<default_opset::Erf>(node.get_ng_inputs().at(0))};
}

2
ngraph/src/ngraph/frontend/onnx_import/op/exp.hpp
View File

@ -30,7 +30,7 @@ namespace ngraph
{
namespace set_1
{
inline NodeVector exp(const Node& node)
inline OutputVector exp(const Node& node)
{
return {std::make_shared<default_opset::Exp>(node.get_ng_inputs().at(0))};
}

6
ngraph/src/ngraph/frontend/onnx_import/op/expand.cpp
View File

@ -30,10 +30,10 @@ namespace ngraph
{
namespace set_1
{
NodeVector expand(const Node& node)
OutputVector expand(const Node& node)
{
const std::shared_ptr<ngraph::Node> data{node.get_ng_inputs().at(0)};
const std::shared_ptr<ngraph::Node> shape{node.get_ng_inputs().at(1)};
const Output<ngraph::Node> data{node.get_ng_inputs().at(0)};
const Output<ngraph::Node> shape{node.get_ng_inputs().at(1)};
return {std::make_shared<default_opset::Broadcast>(
data, shape, ngraph::op::BroadcastType::BIDIRECTIONAL)};

2
ngraph/src/ngraph/frontend/onnx_import/op/expand.hpp
View File

@ -29,7 +29,7 @@ namespace ngraph
// Expand operator has been available since version 8 of the default ONNX operator set.
// Currently, Expand is assigned to version 1 due to temporary reason.
{
NodeVector expand(const Node& node);
OutputVector expand(const Node& node);
} // namespace set_1

6
ngraph/src/ngraph/frontend/onnx_import/op/eye_like.cpp
View File

@ -28,10 +28,10 @@ namespace ngraph
{
namespace set_1
{
NodeVector eye_like(const Node& node)
OutputVector eye_like(const Node& node)
{
const auto input = node.get_ng_inputs().at(0);
const auto& input_shape = input->get_shape();
const auto& input_shape = input.get_shape();
std::int64_t dtype;
element::Type target_type;
@ -44,7 +44,7 @@ namespace ngraph
}
else
{
target_type = input->get_element_type();
target_type = input.get_element_type();
}
CHECK_VALID_NODE(node,

2
ngraph/src/ngraph/frontend/onnx_import/op/eye_like.hpp
View File

@ -27,7 +27,7 @@ namespace ngraph
{
namespace set_1
{
NodeVector eye_like(const Node& node);
OutputVector eye_like(const Node& node);
} // namespace set_1
} // namespace op

2
ngraph/src/ngraph/frontend/onnx_import/op/fake_quantize.cpp
View File

@ -27,7 +27,7 @@ namespace ngraph
{
namespace set_1
{
NodeVector fake_quantize(const onnx_import::Node& node)
OutputVector fake_quantize(const onnx_import::Node& node)
{
const auto inputs = node.get_ng_inputs();
const auto X = inputs.at(0);

2
ngraph/src/ngraph/frontend/onnx_import/op/fake_quantize.hpp
View File

@ -27,7 +27,7 @@ namespace ngraph
{
namespace set_1
{
NodeVector fake_quantize(const Node& node);
OutputVector fake_quantize(const Node& node);
} // namespace set_1

6
ngraph/src/ngraph/frontend/onnx_import/op/flatten.cpp
View File

@ -29,12 +29,12 @@ namespace ngraph
{
namespace set_1
{
NodeVector flatten(const Node& node)
OutputVector flatten(const Node& node)
{
NodeVector inputs{node.get_ng_inputs()};
OutputVector inputs{node.get_ng_inputs()};
auto data = inputs.at(0);
auto axis = node.get_attribute_value<std::int64_t>("axis", 1);
const auto data_rank = data->get_output_partial_shape(0).rank();
const auto data_rank = data.get_partial_shape().rank();
if (data_rank.is_static())
{

2
ngraph/src/ngraph/frontend/onnx_import/op/flatten.hpp
View File

@ -27,7 +27,7 @@ namespace ngraph
{
namespace set_1
{
NodeVector flatten(const Node& node);
OutputVector flatten(const Node& node);
} // namespace set_1

2
ngraph/src/ngraph/frontend/onnx_import/op/floor.hpp
View File

@ -31,7 +31,7 @@ namespace ngraph
{
namespace set_1
{
inline NodeVector floor(const Node& node)
inline OutputVector floor(const Node& node)
{
return {std::make_shared<default_opset::Floor>(node.get_ng_inputs().at(0))};
}

6
ngraph/src/ngraph/frontend/onnx_import/op/gather.hpp
View File

@ -31,14 +31,14 @@ namespace ngraph
{
namespace set_1
{
inline NodeVector gather(const Node& node)
inline OutputVector gather(const Node& node)
{
NodeVector ng_inputs{node.get_ng_inputs()};
OutputVector ng_inputs{node.get_ng_inputs()};
auto data = ng_inputs.at(0);
auto indices = ng_inputs.at(1);
auto axis = node.get_attribute_value<int64_t>("axis", 0);
const auto valid_axis = ngraph::normalize_axis(
node.get_description(), axis, data->get_output_partial_shape(0).rank());
node.get_description(), axis, data.get_partial_shape().rank());
return {std::make_shared<default_opset::Gather>(
data,

7
ngraph/src/ngraph/frontend/onnx_import/op/gather_nd.cpp
View File

@ -14,6 +14,9 @@
// limitations under the License.
//*****************************************************************************
// Disabled in CMakeList
// Update to higher opset required
#include "ngraph/opsets/opset0.hpp"
#include "utils/common.hpp"
@ -25,9 +28,9 @@ namespace ngraph
{
namespace set_1
{
NodeVector gather_nd(const Node& node)
OutputVector gather_nd(const Node& node)
{
NodeVector ng_inputs{node.get_ng_inputs()};
OutputVector ng_inputs{node.get_ng_inputs()};
auto data = ng_inputs.at(0);
auto indices = ng_inputs.at(1);

5
ngraph/src/ngraph/frontend/onnx_import/op/gather_nd.hpp
View File

@ -14,6 +14,9 @@
// limitations under the License.
//*****************************************************************************
// Disabled in CMakeList
// Update to higher opset required
#pragma once
#include "core/node.hpp"
@ -27,7 +30,7 @@ namespace ngraph
{
namespace set_1
{
NodeVector gather_nd(const Node& node);
OutputVector gather_nd(const Node& node);
} // namespace set_1

36
ngraph/src/ngraph/frontend/onnx_import/op/gemm.cpp
View File

@ -32,12 +32,12 @@ namespace ngraph
{
namespace set_1
{
NodeVector gemm(const Node& node)
OutputVector gemm(const Node& node)
{
NodeVector inputs{node.get_ng_inputs()};
std::shared_ptr<ngraph::Node> input_a = inputs.at(0);
std::shared_ptr<ngraph::Node> input_b = inputs.at(1);
std::shared_ptr<ngraph::Node> input_c;
OutputVector inputs{node.get_ng_inputs()};
Output<ngraph::Node> input_a = inputs.at(0);
Output<ngraph::Node> input_b = inputs.at(1);
Output<ngraph::Node> input_c;
if (inputs.size() == 3)
{
@ -46,16 +46,16 @@ namespace ngraph
else
{
input_c = default_opset::Constant::create(
input_b->get_element_type(), ngraph::Shape{}, {0});
input_b.get_element_type(), ngraph::Shape{}, {0});
}
const auto alpha = node.get_attribute_value<float>("alpha", 1);
const auto beta = node.get_attribute_value<float>("beta", 1);
const auto alpha_node = default_opset::Constant::create(
input_b->get_element_type(), Shape{}, {alpha});
input_b.get_element_type(), Shape{}, {alpha});
const auto beta_node = default_opset::Constant::create(
input_c->get_element_type(), Shape{}, {beta});
input_c.get_element_type(), Shape{}, {beta});
const bool trans_a = node.get_attribute_value<int64_t>("transA", 0);
const bool trans_b = node.get_attribute_value<int64_t>("transB", 0);
@ -85,7 +85,7 @@ namespace ngraph
auto beta_times_input_c =
std::make_shared<default_opset::Multiply>(beta_node, input_c);
return NodeVector{
return OutputVector{
std::make_shared<default_opset::Add>(matmul_node, beta_times_input_c)};
}
@ -93,12 +93,12 @@ namespace ngraph
namespace set_6
{
NodeVector gemm(const Node& node)
OutputVector gemm(const Node& node)
{
NodeVector inputs{node.get_ng_inputs()};
std::shared_ptr<ngraph::Node> input_a = inputs.at(0);
std::shared_ptr<ngraph::Node> input_b = inputs.at(1);
std::shared_ptr<ngraph::Node> input_c;
OutputVector inputs{node.get_ng_inputs()};
Output<ngraph::Node> input_a = inputs.at(0);
Output<ngraph::Node> input_b = inputs.at(1);
Output<ngraph::Node> input_c;
if (inputs.size() == 3)
{
@ -107,16 +107,16 @@ namespace ngraph
else
{
input_c = default_opset::Constant::create(
input_b->get_element_type(), ngraph::Shape{}, {0});
input_b.get_element_type(), ngraph::Shape{}, {0});
}
const auto alpha = node.get_attribute_value<float>("alpha", 1);
const auto beta = node.get_attribute_value<float>("beta", 1);
const auto alpha_node = default_opset::Constant::create(
input_b->get_element_type(), Shape{}, {alpha});
input_b.get_element_type(), Shape{}, {alpha});
const auto beta_node = default_opset::Constant::create(
input_c->get_element_type(), Shape{}, {beta});
input_c.get_element_type(), Shape{}, {beta});
const bool trans_a = node.get_attribute_value<int64_t>("transA", 0);
const bool trans_b = node.get_attribute_value<int64_t>("transB", 0);
@ -133,7 +133,7 @@ namespace ngraph
auto beta_times_input_c =
std::make_shared<default_opset::Multiply>(beta_node, input_c);
return NodeVector{
return OutputVector{
std::make_shared<default_opset::Add>(matmul_node, beta_times_input_c)};
}

4
ngraph/src/ngraph/frontend/onnx_import/op/gemm.hpp
View File

@ -27,13 +27,13 @@ namespace ngraph
{
namespace set_1
{
NodeVector gemm(const Node& node);
OutputVector gemm(const Node& node);
} // namespace set_1
namespace set_6
{
NodeVector gemm(const Node& node);
OutputVector gemm(const Node& node);
} // namespace set_6

2
ngraph/src/ngraph/frontend/onnx_import/op/global_average_pool.cpp
View File

@ -27,7 +27,7 @@ namespace ngraph
{
namespace set_1
{
NodeVector global_average_pool(const Node& node)
OutputVector global_average_pool(const Node& node)
{
return pooling::GlobalPoolingFactory(node).make_avg_pool();
}

2
ngraph/src/ngraph/frontend/onnx_import/op/global_average_pool.hpp
View File

@ -33,7 +33,7 @@ namespace ngraph
///
/// \return The vector containing Ngraph nodes producing output of ONNX
/// GlobalAveragePool operation.
NodeVector global_average_pool(const Node& node);
OutputVector global_average_pool(const Node& node);
} // namespace set_1

2
ngraph/src/ngraph/frontend/onnx_import/op/global_max_pool.cpp
View File

@ -27,7 +27,7 @@ namespace ngraph
{
namespace set_1
{
NodeVector global_max_pool(const Node& node)
OutputVector global_max_pool(const Node& node)
{
return pooling::GlobalPoolingFactory(node).make_max_pool();
}

2
ngraph/src/ngraph/frontend/onnx_import/op/global_max_pool.hpp
View File

@ -33,7 +33,7 @@ namespace ngraph
///
/// \return The vector containing Ngraph nodes producing output of ONNX
/// GlobalMaxPool operation.
NodeVector global_max_pool(const Node& node);
OutputVector global_max_pool(const Node& node);
} // namespace set_1

2
ngraph/src/ngraph/frontend/onnx_import/op/greater.hpp
View File

@ -31,7 +31,7 @@ namespace ngraph
{
namespace set_1
{
inline NodeVector greater(const Node& node)
inline OutputVector greater(const Node& node)
{
return {std::make_shared<default_opset::Greater>(node.get_ng_inputs().at(0),
node.get_ng_inputs().at(1))};

10
ngraph/src/ngraph/frontend/onnx_import/op/gru.cpp
View File

@ -46,7 +46,7 @@ namespace ngraph
if (linear_before_reset)
{
const auto& ng_inputs = node.get_ng_inputs();
const auto el_type = ng_inputs.at(0)->get_output_element_type(0);
const auto el_type = ng_inputs.at(0).get_element_type();
if (ng_inputs.size() > 3 && !ngraph::op::is_null(ng_inputs.at(3)))
{
@ -68,7 +68,7 @@ namespace ngraph
// ]
m_map[recurrent::OpInput::B] =
std::make_shared<default_opset::Concat>(
NodeVector{wr_z_bias,
OutputVector{wr_z_bias,
wr_r_bias,
split_bias.at(2),
split_bias.at(5)},
@ -77,9 +77,9 @@ namespace ngraph
else
{
const std::size_t hidden_size =
m_map[recurrent::OpInput::R]->get_shape().back();
m_map[recurrent::OpInput::R].get_shape().back();
const std::size_t num_directions =
m_map[recurrent::OpInput::W]->get_shape().front();
m_map[recurrent::OpInput::W].get_shape().front();
m_map[recurrent::OpInput::B] =
std::make_shared<default_opset::Constant>(
@ -110,7 +110,7 @@ namespace ngraph
};
}
NodeVector gru(const Node& node)
OutputVector gru(const Node& node)
{
constexpr std::size_t gates_count = 3;
GRUInputMap input_map{node, gates_count};

2
ngraph/src/ngraph/frontend/onnx_import/op/gru.hpp
View File

@ -27,7 +27,7 @@ namespace ngraph
{
namespace set_1
{
NodeVector gru(const Node& node);
OutputVector gru(const Node& node);
} // namespace set_1

6
ngraph/src/ngraph/frontend/onnx_import/op/hard_sigmoid.cpp
View File

@ -27,17 +27,17 @@ namespace ngraph
{
namespace set_1
{
NodeVector hard_sigmoid(const Node& node)
OutputVector hard_sigmoid(const Node& node)
{
const auto data = node.get_ng_inputs().at(0);
const auto alpha = default_opset::Constant::create<double>(
data->get_element_type(),
data.get_element_type(),
Shape{},
std::vector<double>{node.get_attribute_value<double>("alpha", 0.2)});
const auto beta = default_opset::Constant::create<double>(
data->get_element_type(),
data.get_element_type(),
Shape{},
std::vector<double>{node.get_attribute_value<double>("beta", 0.5)});

2
ngraph/src/ngraph/frontend/onnx_import/op/hard_sigmoid.hpp
View File

@ -27,7 +27,7 @@ namespace ngraph
{
namespace set_1
{
NodeVector hard_sigmoid(const Node& node);
OutputVector hard_sigmoid(const Node& node);
} // namespace set_1

11
ngraph/src/ngraph/frontend/onnx_import/op/hardmax.cpp
View File

@ -31,10 +31,10 @@ namespace ngraph
{
namespace set_1
{
NodeVector hardmax(const Node& node)
OutputVector hardmax(const Node& node)
{
const auto input = node.get_ng_inputs().at(0);
const auto& input_shape = input->get_output_partial_shape(0);
const auto& input_shape = input.get_partial_shape();
auto axis = node.get_attribute_value<std::int64_t>("axis", 1);
if (input_shape.rank().is_static())
@ -48,8 +48,7 @@ namespace ngraph
const auto coerced_tensor_shape =
std::make_shared<default_opset::ShapeOf>(coerced_tensor);
std::shared_ptr<ngraph::Node> row_size =
std::make_shared<default_opset::Gather>(
Output<ngraph::Node> row_size = std::make_shared<default_opset::Gather>(
coerced_tensor_shape,
default_opset::Constant::create(element::i64, {1}, {1}),
default_opset::Constant::create(element::i64, {}, {0}));
@ -70,8 +69,8 @@ namespace ngraph
const auto results = std::make_shared<default_opset::OneHot>(
topk->output(1), row_size, on_value, off_value, indices_axis);
const auto converted_results = std::make_shared<default_opset::Convert>(
results, input->get_element_type());
const auto converted_results =
std::make_shared<default_opset::Convert>(results, input.get_element_type());
if (input_shape.is_static())
{

2
ngraph/src/ngraph/frontend/onnx_import/op/hardmax.hpp
View File

@ -27,7 +27,7 @@ namespace ngraph
{
namespace set_1
{
NodeVector hardmax(const Node& node);
OutputVector hardmax(const Node& node);
} // namespace set_1
} // namespace op

6
ngraph/src/ngraph/frontend/onnx_import/op/identity.hpp
View File

@ -30,17 +30,17 @@ namespace ngraph
{
namespace set_1
{
inline NodeVector identity(const Node& node)
inline OutputVector identity(const Node& node)
{
auto input = node.get_ng_inputs().at(0);
if (input->get_element_type() == ngraph::element::boolean)
if (input.get_element_type() == ngraph::element::boolean)
{
const auto logic_zero =
default_opset::Constant::create(ngraph::element::boolean, {}, {false});
return {std::make_shared<default_opset::LogicalOr>(input, logic_zero)};
}
const auto zero =
default_opset::Constant::create(input->get_element_type(), {}, {0});
default_opset::Constant::create(input.get_element_type(), {}, {0});
return {std::make_shared<default_opset::Add>(input, zero)};
}
} // namespace set_1

4
ngraph/src/ngraph/frontend/onnx_import/op/image_scaler.cpp
View File

@ -25,14 +25,14 @@ namespace ngraph
{
namespace set_1
{
NodeVector image_scaler(const Node& node)
OutputVector image_scaler(const Node& node)
{
const auto inputs = node.get_ng_inputs();
NGRAPH_CHECK(
inputs.size() == 1, "ImageScaler 1 input tensor. Got: ", inputs.size());
const auto data = inputs[0];
const auto& data_shape = data->get_output_partial_shape(0);
const auto& data_shape = data.get_partial_shape();
NGRAPH_CHECK(data_shape.rank().same_scheme({4}),
"ImageScaler expects a 4D tensor with NCHW format. Got: ",
data_shape);

2
ngraph/src/ngraph/frontend/onnx_import/op/image_scaler.hpp
View File

@ -27,7 +27,7 @@ namespace ngraph
{
namespace set_1
{
NodeVector image_scaler(const Node& node);
OutputVector image_scaler(const Node& node);
}
}
}

2
ngraph/src/ngraph/frontend/onnx_import/op/instance_norm.cpp
View File

@ -39,7 +39,7 @@ namespace ngraph
{
namespace set_1
{
NodeVector instance_norm(const Node& node)
OutputVector instance_norm(const Node& node)
{
Output<ngraph::Node> data(node.get_ng_inputs().at(0));
Output<ngraph::Node> scale(node.get_ng_inputs().at(1));

Some files were not shown because too many files have changed in this diff Show More