bool evaluate(const HostTensorVector& outputs,
const HostTensorVector& inputs) const override;
+ bool constant_fold(OutputVector& output_values,
+ const OutputVector& inputs_values) override;
+
private:
static const int PARAMS;
static const int INDICES;
static const int AXIS;
};
- }
- }
-}
+ } // namespace v1
+ } // namespace op
+} // namespace ngraph
clone_with_new_inputs(const OutputVector& new_args) const override;
void validate_and_infer_types() override;
+ virtual bool evaluate(const HostTensorVector& output_values,
+ const HostTensorVector& input_values) const override;
+
/// \return The index of the one-hot axis.
int64_t get_axis() const { return m_axis; }
void set_axis(int64_t axis) { m_axis = axis; }
protected:
int64_t m_axis;
};
- }
- }
-}
+ } // namespace v1
+ } // namespace op
+} // namespace ngraph
RoundMode m_round_mode;
NGRAPH_SUPPRESS_DEPRECATED_END
};
- }
+ } // namespace v0
NGRAPH_SUPPRESS_DEPRECATED_START
using v0::Quantize;
NGRAPH_SUPPRESS_DEPRECATED_END
- }
-}
+ } // namespace op
+} // namespace ngraph
void validate_and_infer_types() override;
NGRAPH_SUPPRESS_DEPRECATED_END
};
- }
+ } // namespace v0
namespace v1
{
}
// TODO: Move all uses of get_autob to get_auto_broadcast() and remove this.
const AutoBroadcastSpec& get_autob() const override { return m_auto_broadcast; }
+ virtual bool evaluate(const HostTensorVector& output_values,
+ const HostTensorVector& input_values) const override;
+
private:
AutoBroadcastSpec m_auto_broadcast;
};
- }
+ } // namespace v1
NGRAPH_SUPPRESS_DEPRECATED_START
using v0::Select;
NGRAPH_SUPPRESS_DEPRECATED_END
- }
-}
+ } // namespace op
+} // namespace ngraph
class NGRAPH_API ngraph::pass::ConstantFolding : public ngraph::pass::GraphRewrite
{
public:
- ConstantFolding(const ngraph::BuildNodeExecutorMap& cfmap = ngraph::BuildNodeExecutorMap())
- : GraphRewrite()
- {
- m_cfmap = cfmap;
- m_enable_shape_inference = true;
- construct_constant_quantize();
- construct_constant_convert();
- construct_constant_arithmetic_reduction();
- construct_constant_logical_reduction();
- construct_constant_gather_with_subgraph();
- construct_constant_scatter_elements_update();
- construct_constant_select();
- construct_constant_one_hot();
- construct_constant_default();
- }
+ ConstantFolding(const ngraph::BuildNodeExecutorMap& cfmap = ngraph::BuildNodeExecutorMap());
private:
- void construct_constant_quantize();
- void construct_constant_convert();
- void construct_constant_arithmetic_reduction();
- void construct_constant_logical_reduction();
- void construct_constant_gather_with_subgraph();
- void construct_constant_scatter_elements_update();
- void construct_constant_select();
- void construct_constant_one_hot();
- void construct_constant_default();
-
- bool cf_is_disabled(const std::shared_ptr<Node>&);
-
void copy_runtime_info_to_target_inputs(const std::shared_ptr<Node>& node,
const Output<Node>& replacement);
namespace reference
{
template <typename T>
- void min(const T* arg, T* out, const Shape& in_shape, const AxisSet& reduction_axes)
+ void min(const T* arg,
+ T* out,
+ const Shape& in_shape,
+ const AxisSet& reduction_axes,
+ const bool keep_dims)
{
T minval = std::numeric_limits<T>::has_infinity ? std::numeric_limits<T>::infinity()
: std::numeric_limits<T>::max();
- auto out_shape = reduce(in_shape, reduction_axes, false);
+ const auto out_shape = reduce(in_shape, reduction_axes, keep_dims);
CoordinateTransform output_transform(out_shape);
for (const Coordinate& output_coord : output_transform)
for (const Coordinate& input_coord : input_transform)
{
- Coordinate output_coord = reduce(input_coord, reduction_axes, false);
+ Coordinate output_coord = reduce(input_coord, reduction_axes, keep_dims);
T x = arg[input_transform.index(input_coord)];
T min = out[output_transform.index(output_coord)];
}
}
}
- }
- }
-}
+ } // namespace reference
+ } // namespace runtime
+} // namespace ngraph
#include "ngraph/check.hpp"
#include "ngraph/runtime/reference/eval_helpers.hpp"
+#include "ngraph/util.hpp"
namespace ngraph
{
{
AxisSet extract_reduction_axes(const HostTensorPtr& axes, const char* op_name)
{
- const auto axes_count = axes->get_element_count();
- const auto axes_buffer = axes->get_data_ptr<int64_t>();
+ const auto axes_in_tensor = host_tensor_2_vector<int64_t>(axes);
- const bool negative_axis_received = std::any_of(
- axes_buffer, axes_buffer + axes_count, [](const int64_t axis) { return axis < 0; });
+ const bool negative_axis_received =
+ std::any_of(axes_in_tensor.begin(), axes_in_tensor.end(), [](const int64_t axis) {
+ return axis < 0;
+ });
NGRAPH_CHECK(!negative_axis_received,
"Negative axis value received in the ",
op_name,
" evaluation. This case is not supported.");
- return AxisSet(std::vector<AxisSet::value_type>(axes_buffer, axes_buffer + axes_count));
+ return AxisSet(
+ std::vector<AxisSet::value_type>(axes_in_tensor.begin(), axes_in_tensor.end()));
}
- }
-}
+ } // namespace eval
+} // namespace ngraph
#include "ngraph/op/gather.hpp"
#include "itt.hpp"
+#include "ngraph/op/concat.hpp"
#include "ngraph/op/constant.hpp"
+#include "ngraph/op/squeeze.hpp"
#include "ngraph/runtime/host_tensor.hpp"
#include "ngraph/runtime/reference/gather.hpp"
#include "ngraph/shape.hpp"
}
return rc;
}
-}
+
+ bool cf_gather_with_subgraph(OutputVector& output_values,
+ const OutputVector& input_values,
+ const PartialShape& gather_ps)
+ {
+ if (gather_ps.is_dynamic() || input_values.size() != 3)
+ {
+ return false;
+ }
+
+ const auto concat =
+ std::dynamic_pointer_cast<op::Concat>(input_values[0].get_node_shared_ptr());
+ const auto indices =
+ std::dynamic_pointer_cast<op::Constant>(input_values[1].get_node_shared_ptr());
+ const auto axis =
+ std::dynamic_pointer_cast<op::Constant>(input_values[2].get_node_shared_ptr());
+
+ if (!concat || !indices || !axis)
+ {
+ return false;
+ }
+
+ // only along axis=0
+ if (axis->cast_vector<int64_t>()[0] != 0 || concat->get_axis() != 0)
+ {
+ return false;
+ }
+ // only single indices are accepted
+ const auto indices_shape = indices->get_shape();
+ if (indices_shape.size() > 1 || (indices_shape.size() == 1 && indices_shape[0] > 1))
+ {
+ return false;
+ }
+ // concat inputs are 1D and their count is equal to Concat output shape
+ if (concat->get_output_partial_shape(0).is_dynamic())
+ {
+ return false;
+ }
+ const auto concat_inputs = concat->inputs();
+ // concat inputs must be single elements
+ if (concat_inputs.size() != shape_size(concat->get_shape()))
+ {
+ return false;
+ }
+
+ const int64_t rank = concat->get_shape()[0];
+ const int64_t raw_index = indices->cast_vector<int64_t>()[0];
+ const int64_t positive_index = raw_index < 0 ? rank + raw_index : raw_index;
+ NGRAPH_CHECK(positive_index >= 0 && positive_index < rank);
+
+ // gather takes exactly one element out of the Concat output
+ const auto gathered_concat_input =
+ concat_inputs[positive_index].get_source_output().get_node_shared_ptr();
+ // Concat inputs are 1D, resulting tensor shape depends on Gather indices
+ auto gathered = gathered_concat_input;
+ if (indices_shape.empty())
+ {
+ // gathering a scalar
+ const auto axes = op::Constant::create(element::i64, Shape{1}, {0});
+ gathered = make_shared<op::v0::Squeeze>(gathered_concat_input, axes);
+ }
+
+ output_values[0] = gathered;
+
+ return true;
+ }
+} // namespace gather
bool op::v1::Gather::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const
{
}
return gather::evaluate_gather(inputs[0], inputs[1], outputs[0], axis);
}
+
+bool op::v1::Gather::constant_fold(OutputVector& output_values, const OutputVector& input_values)
+{
+ // try the regular constant folding just for the Gather node
+ if (Node::constant_fold(output_values, input_values))
+ {
+ return true;
+ }
+ else
+ {
+ return gather::cf_gather_with_subgraph(
+ output_values, input_values, get_output_partial_shape(0));
+ }
+}
bool evaluate(const HostTensorPtr& arg,
const HostTensorPtr& out,
const AxisSet& axes,
- bool keep_dims)
+ const bool keep_dims)
{
out->set_shape(reduce(arg->get_shape(), axes, keep_dims));
runtime::reference::min(
- arg->get_data_ptr<ET>(), out->get_data_ptr<ET>(), arg->get_shape(), axes);
+ arg->get_data_ptr<ET>(), out->get_data_ptr<ET>(), arg->get_shape(), axes, keep_dims);
return true;
}
bool evaluate_min(const HostTensorPtr& arg,
const HostTensorPtr& out,
const AxisSet& axes,
- bool keep_dims)
+ const bool keep_dims)
{
bool rc = true;
switch (arg->get_element_type())
}
return rc;
}
-}
+} // namespace minop
constexpr NodeTypeInfo op::v1::ReduceMin::type_info;
#include "ngraph/op/one_hot.hpp"
#include "ngraph/attribute_visitor.hpp"
#include "ngraph/op/util/op_types.hpp"
+#include "ngraph/runtime/reference/one_hot.hpp"
#include "ngraph/validation_util.hpp"
using namespace std;
return make_shared<v1::OneHot>(
new_args.at(0), new_args.at(1), new_args.at(2), new_args.at(3), m_axis);
}
+
+namespace detail
+{
+ template <typename ind_t, typename out_t>
+ void evaluate(const HostTensorVector& output_values,
+ const HostTensorVector& input_values,
+ const int64_t axis)
+ {
+ const auto& indices = input_values[0];
+ const auto& depth = input_values[1];
+ const auto& on_value = input_values[2];
+ const auto& off_value = input_values[3];
+
+ const auto& out = output_values[0];
+
+ runtime::reference::one_hot<ind_t, out_t>(indices->get_data_ptr<ind_t>(),
+ out->get_data_ptr<out_t>(),
+ indices->get_shape(),
+ out->get_shape(),
+ axis,
+ on_value->get_data_ptr<out_t>()[0],
+ off_value->get_data_ptr<out_t>()[0]);
+ }
+
+ template <typename out_t>
+ bool dispatch_by_output_type(const HostTensorVector& output_values,
+ const HostTensorVector& input_values,
+ const int64_t axis)
+ {
+ const auto& indices = input_values[0];
+
+ switch (indices->get_element_type())
+ {
+ case element::Type_t::i32:
+ evaluate<int32_t, out_t>(output_values, input_values, axis);
+ break;
+ case element::Type_t::i64:
+ evaluate<int64_t, out_t>(output_values, input_values, axis);
+ break;
+ default: return false; break;
+ }
+
+ return true;
+ }
+
+ bool evaluate_onehot(const HostTensorVector& output_values,
+ const HostTensorVector& input_values,
+ const int64_t axis)
+ {
+ const auto& on_value = input_values[2];
+
+ switch (on_value->get_element_type())
+ {
+ case element::Type_t::boolean:
+ return dispatch_by_output_type<char>(output_values, input_values, axis);
+ break;
+ case element::Type_t::f32:
+ return dispatch_by_output_type<float>(output_values, input_values, axis);
+ break;
+ case element::Type_t::i32:
+ return dispatch_by_output_type<int32_t>(output_values, input_values, axis);
+ break;
+ case element::Type_t::i64:
+ return dispatch_by_output_type<int64_t>(output_values, input_values, axis);
+ break;
+ default: return false;
+ }
+ }
+} // namespace detail
+
+bool op::v1::OneHot::evaluate(const HostTensorVector& output_values,
+ const HostTensorVector& input_values) const
+{
+ return detail::evaluate_onehot(output_values, input_values, get_axis());
+}
//*****************************************************************************
#include "ngraph/op/quantize.hpp"
+#include "ngraph/runtime/host_tensor.hpp"
+#include "ngraph/runtime/reference/quantize.hpp"
#include "ngraph/shape_util.hpp"
NGRAPH_SUPPRESS_DEPRECATED_START
return false;
}
}
-}
+} // namespace
bool op::v1::ReduceLogicalAnd::evaluate(const HostTensorVector& outputs,
const HostTensorVector& inputs) const
const auto& axes = inputs[1];
const auto& out = outputs[0];
- if (data->get_element_type() != element::boolean || axes->get_element_type() != element::i64)
+ if (data->get_element_type() != element::boolean ||
+ !axes->get_element_type().is_integral_number())
{
return false;
}
return false;
}
}
-}
+} // namespace
bool op::v1::ReduceLogicalOr::evaluate(const HostTensorVector& outputs,
const HostTensorVector& inputs) const
const auto& axes = inputs[1];
const auto& out = outputs[0];
- if (data->get_element_type() != element::boolean || axes->get_element_type() != element::i64)
+ if (data->get_element_type() != element::boolean ||
+ !axes->get_element_type().is_integral_number())
{
return false;
}
switch (out->get_element_type())
{
+ TYPE_CASE(i16)(arg0, arg1, arg2, arg3, out, normalized_axis);
+ break;
TYPE_CASE(i32)(arg0, arg1, arg2, arg3, out, normalized_axis);
break;
TYPE_CASE(i64)(arg0, arg1, arg2, arg3, out, normalized_axis);
#include "ngraph/op/multiply.hpp"
#include "ngraph/op/not.hpp"
#include "ngraph/op/select.hpp"
+#include "ngraph/runtime/reference/select.hpp"
NGRAPH_SUPPRESS_DEPRECATED_START
return true;
}
+namespace detail
+{
+ template <element::Type_t ET>
+ bool evaluate(const HostTensorVector& output_values,
+ const HostTensorVector& input_values,
+ const op::AutoBroadcastSpec& autob)
+ {
+ using T = typename element_type_traits<ET>::value_type;
+
+ const auto& in_cond = input_values[0];
+ const auto& in_then = input_values[1];
+ const auto& in_else = input_values[2];
+
+ const auto& out = output_values[0];
+
+ runtime::reference::select<T>(in_cond->get_data_ptr<char>(),
+ in_then->get_data_ptr<T>(),
+ in_else->get_data_ptr<T>(),
+ out->get_data_ptr<T>(),
+ in_cond->get_shape(),
+ in_then->get_shape(),
+ in_else->get_shape(),
+ autob);
+ return true;
+ }
+
+ bool evaluate_select(const HostTensorVector& output_values,
+ const HostTensorVector& input_values,
+ const op::AutoBroadcastSpec& autob,
+ const element::Type_t& et)
+ {
+ bool rc = false;
+
+ switch (et)
+ {
+ TYPE_CASE(i8)(output_values, input_values, autob);
+ break;
+ TYPE_CASE(i16)(output_values, input_values, autob);
+ break;
+ TYPE_CASE(i32)(output_values, input_values, autob);
+ break;
+ TYPE_CASE(i64)(output_values, input_values, autob);
+ break;
+ TYPE_CASE(u8)(output_values, input_values, autob);
+ break;
+ TYPE_CASE(u16)(output_values, input_values, autob);
+ break;
+ TYPE_CASE(u32)(output_values, input_values, autob);
+ break;
+ TYPE_CASE(u64)(output_values, input_values, autob);
+ break;
+ TYPE_CASE(bf16)(output_values, input_values, autob);
+ break;
+ TYPE_CASE(f32)(output_values, input_values, autob);
+ break;
+ TYPE_CASE(f64)(output_values, input_values, autob);
+ break;
+ TYPE_CASE(boolean)(output_values, input_values, autob);
+ break;
+ default: rc = false; break;
+ }
+
+ return rc;
+ }
+} // namespace detail
+
+bool op::v1::Select::evaluate(const HostTensorVector& output_values,
+ const HostTensorVector& input_values) const
+{
+ const auto autob = get_auto_broadcast();
+
+ return detail::evaluate_select(output_values, input_values, autob, get_output_element_type(0));
+}
+
constexpr NodeTypeInfo op::v0::Select::type_info;
op::v0::Select::Select(const Output<Node>& arg0, const Output<Node>& arg1, const Output<Node>& arg2)
using namespace std;
using namespace ngraph;
-bool ngraph::pass::revalidate_and_ensure_static(shared_ptr<Node> n)
-{
- n->revalidate_and_infer_types();
- for (auto& o : n->outputs())
- {
- if (o.get_partial_shape().is_dynamic() || o.get_element_type().is_dynamic())
- {
- return false;
- }
- }
- return true;
-}
-
-bool ngraph::pass::ConstantFolding::cf_is_disabled(const std::shared_ptr<Node>& node)
-{
- auto& rt_info = node->get_rt_info();
- return rt_info.count("DISABLED_CONSTANT_FOLDING") != 0;
-}
-
-void ngraph::pass::ConstantFolding::copy_runtime_info_to_target_inputs(
- const std::shared_ptr<Node>& node, const Output<Node>& replacement)
+ngraph::pass::ConstantFolding::ConstantFolding(const ngraph::BuildNodeExecutorMap& cfmap)
+ : GraphRewrite()
+ , m_cfmap{cfmap}
{
- for (auto& input : replacement.get_target_inputs())
- {
- auto consumer = input.get_node()->shared_from_this();
- copy_runtime_info({node, consumer}, consumer);
- }
-}
+ m_enable_shape_inference = true;
-void ngraph::pass::ConstantFolding::construct_constant_default()
-{
m_matchers.push_back(std::make_shared<MatcherPass>(
"Constant folding defaults",
nullptr,
},
PassProperty::CHANGE_DYNAMIC_STATE));
}
+
+bool ngraph::pass::revalidate_and_ensure_static(shared_ptr<Node> n)
+{
+ n->revalidate_and_infer_types();
+ for (auto& o : n->outputs())
+ {
+ if (o.get_partial_shape().is_dynamic() || o.get_element_type().is_dynamic())
+ {
+ return false;
+ }
+ }
+ return true;
+}
+
+void ngraph::pass::ConstantFolding::copy_runtime_info_to_target_inputs(
+ const std::shared_ptr<Node>& node, const Output<Node>& replacement)
+{
+ for (auto& input : replacement.get_target_inputs())
+ {
+ auto consumer = input.get_node()->shared_from_this();
+ copy_runtime_info({node, consumer}, consumer);
+ }
+}
+++ /dev/null
-//*****************************************************************************
-// Copyright 2017-2020 Intel Corporation
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//*****************************************************************************
-
-#include "constant_folding.hpp"
-#include "ngraph/log.hpp"
-#include "ngraph/op/constant.hpp"
-#include "ngraph/op/max.hpp"
-#include "ngraph/op/min.hpp"
-#include "ngraph/op/reduce_mean.hpp"
-#include "ngraph/op/reduce_prod.hpp"
-#include "ngraph/op/reduce_sum.hpp"
-#include "ngraph/runtime/reference/max.hpp"
-#include "ngraph/runtime/reference/mean.hpp"
-#include "ngraph/runtime/reference/min.hpp"
-#include "ngraph/runtime/reference/product.hpp"
-#include "ngraph/runtime/reference/sum.hpp"
-
-NGRAPH_SUPPRESS_DEPRECATED_START
-
-using namespace std;
-using namespace ngraph;
-
-template <typename T>
-static shared_ptr<op::Constant>
- fold_constant_arithmetic_reduction_helper(shared_ptr<op::Constant> constant,
- shared_ptr<Node> reduction_node)
-{
- const Shape& out_shape = reduction_node->get_shape();
- runtime::AlignedBuffer buffer(shape_size(out_shape) * sizeof(T));
- T* data_ptr = buffer.get_ptr<T>();
-
- if (auto reduce_max = as_type_ptr<op::v1::ReduceMax>(reduction_node))
- {
- runtime::reference::max<T>(constant->get_data_ptr<T>(),
- data_ptr,
- constant->get_output_shape(0),
- reduce_max->get_reduction_axes(),
- reduce_max->get_keep_dims());
- }
- else if (auto reduce_min = as_type_ptr<op::v1::ReduceMin>(reduction_node))
- {
- runtime::reference::min<T>(constant->get_data_ptr<T>(),
- data_ptr,
- constant->get_output_shape(0),
- reduce_min->get_reduction_axes());
- }
- else if (auto reduce_prod = as_type_ptr<op::v1::ReduceProd>(reduction_node))
- {
- runtime::reference::product<T>(constant->get_data_ptr<T>(),
- data_ptr,
- constant->get_output_shape(0),
- reduce_prod->get_reduction_axes(),
- reduce_prod->get_keep_dims());
- }
- else if (auto reduce_sum = as_type_ptr<op::v1::ReduceSum>(reduction_node))
- {
- runtime::reference::sum<T>(constant->get_data_ptr<T>(),
- data_ptr,
- constant->get_output_shape(0),
- reduce_sum->get_reduction_axes(),
- reduce_sum->get_keep_dims());
- }
- else if (auto reduce_mean = as_type_ptr<op::v1::ReduceMean>(reduction_node))
- {
- runtime::reference::mean<T>(constant->get_data_ptr<T>(),
- data_ptr,
- constant->get_output_shape(0),
- reduce_mean->get_reduction_axes(),
- reduce_mean->get_keep_dims());
- }
- else
- {
- NGRAPH_CHECK(false,
- "Internal nGraph error: Ops handled in "
- "fold_constant_arithmetic_reduction_helper must be consistent with those "
- "matched in construct_constant_arithmetic_reduction");
- }
-
- return make_shared<op::Constant>(
- reduction_node->get_output_element_type(0), reduction_node->get_shape(), data_ptr);
-}
-
-static shared_ptr<op::Constant>
- fold_constant_arithmetic_reduction(shared_ptr<op::Constant> constant,
- shared_ptr<Node> reduction_node)
-{
- auto& input_element_type = constant->get_output_element_type(0);
-
- switch (input_element_type)
- {
- case element::Type_t::undefined:
- NGRAPH_CHECK(false,
- "Encountered 'undefined' element type in fold_constant_arithmetic_reduction");
- break;
- case element::Type_t::dynamic:
- NGRAPH_CHECK(false,
- "Encountered 'dynamic' element type in fold_constant_arithmetic_reduction");
- break;
- case element::Type_t::u1:
- NGRAPH_CHECK(false, "Encountered 'u1' element type in fold_constant_arithmetic_reduction");
- break;
- case element::Type_t::boolean:
- return fold_constant_arithmetic_reduction_helper<char>(constant, reduction_node);
- case element::Type_t::bf16:
- return fold_constant_arithmetic_reduction_helper<bfloat16>(constant, reduction_node);
- case element::Type_t::f16:
- return fold_constant_arithmetic_reduction_helper<float16>(constant, reduction_node);
- case element::Type_t::f32:
- return fold_constant_arithmetic_reduction_helper<float>(constant, reduction_node);
- case element::Type_t::f64:
- return fold_constant_arithmetic_reduction_helper<double>(constant, reduction_node);
- case element::Type_t::i8:
- return fold_constant_arithmetic_reduction_helper<int8_t>(constant, reduction_node);
- case element::Type_t::i16:
- return fold_constant_arithmetic_reduction_helper<int16_t>(constant, reduction_node);
- case element::Type_t::i32:
- return fold_constant_arithmetic_reduction_helper<int32_t>(constant, reduction_node);
- case element::Type_t::i64:
- return fold_constant_arithmetic_reduction_helper<int64_t>(constant, reduction_node);
- case element::Type_t::u8:
- return fold_constant_arithmetic_reduction_helper<uint8_t>(constant, reduction_node);
- case element::Type_t::u16:
- return fold_constant_arithmetic_reduction_helper<uint16_t>(constant, reduction_node);
- case element::Type_t::u32:
- return fold_constant_arithmetic_reduction_helper<uint32_t>(constant, reduction_node);
- case element::Type_t::u64:
- return fold_constant_arithmetic_reduction_helper<uint64_t>(constant, reduction_node);
- }
-
- NGRAPH_UNREACHABLE("Unexpected switch case");
-}
-
-void pass::ConstantFolding::construct_constant_arithmetic_reduction()
-{
- auto constant_data_label = make_shared<pattern::op::Label>(
- element::i32, Shape{2, 3, 4}, pattern::has_class<op::Constant>());
- auto constant_axes_label =
- make_shared<pattern::op::Label>(element::i64, Shape{2}, pattern::has_class<op::Constant>());
- auto is_supported_reduction = [](std::shared_ptr<Node> n) {
- return (pattern::has_class<op::v1::ReduceMax>()(n) ||
- pattern::has_class<op::v1::ReduceMin>()(n) ||
- pattern::has_class<op::v1::ReduceProd>()(n) ||
- pattern::has_class<op::v1::ReduceSum>()(n) ||
- pattern::has_class<op::v1::ReduceMean>()(n));
- };
- auto reduction =
- std::make_shared<pattern::op::Any>(element::i32,
- Shape{2},
- is_supported_reduction,
- NodeVector{constant_data_label, constant_axes_label});
-
- auto constant_arithmetic_reduction_callback = [this, constant_data_label](pattern::Matcher& m) {
- NGRAPH_DEBUG << "In callback for constant_arithmetic_reduction_callback against node = "
- << m.get_match_root()->get_name();
-
- auto pattern_map = m.get_pattern_map();
-
- auto constant_match = static_pointer_cast<op::Constant>(pattern_map[constant_data_label]);
- auto reduction_match = m.get_match_root();
-
- if (cf_is_disabled(reduction_match))
- return false;
-
- NGRAPH_CHECK(revalidate_and_ensure_static(reduction_match));
-
- auto const_node = fold_constant_arithmetic_reduction(constant_match, reduction_match);
- const_node->set_friendly_name(reduction_match->get_friendly_name());
- replace_node(reduction_match, const_node);
- copy_runtime_info_to_target_inputs(reduction_match, const_node);
-
- return true;
- };
-
- auto arithmetic_reduction_matcher =
- make_shared<pattern::Matcher>(reduction, "ConstantFolding.ConstantArithmeticReduction");
- NGRAPH_SUPPRESS_DEPRECATED_START
- this->add_matcher(arithmetic_reduction_matcher,
- constant_arithmetic_reduction_callback,
- PassProperty::CHANGE_DYNAMIC_STATE);
- NGRAPH_SUPPRESS_DEPRECATED_END
-}
+++ /dev/null
-//*****************************************************************************
-// Copyright 2017-2020 Intel Corporation
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//*****************************************************************************
-
-#include "constant_folding.hpp"
-#include "ngraph/log.hpp"
-#include "ngraph/op/convert.hpp"
-#include "ngraph/runtime/reference/convert.hpp"
-
-using namespace std;
-using namespace ngraph;
-
-// Helper for mapping element::Types to runtime::reference::convert, which is templated in C++
-// data types. Used by fold_constant_convert and fold_constant_convert_helper0, which respectively
-// determine the appropriate C++ types for "TI" (input type) and "TO" (output type).
-template <typename TI, typename TO>
-shared_ptr<op::Constant> fold_constant_convert_helper1(shared_ptr<op::Constant> constant,
- const element::Type& output_element_type)
-{
- const Shape& out_shape = constant->get_shape();
- runtime::AlignedBuffer buffer(shape_size(out_shape) * sizeof(TO));
- TO* data_ptr = buffer.get_ptr<TO>();
-
- runtime::reference::convert<TI, TO>(
- constant->get_data_ptr<TI>(), data_ptr, shape_size(out_shape));
-
- return make_shared<op::Constant>(output_element_type, out_shape, data_ptr);
-}
-
-// Helper for mapping element::Types to runtime::reference::convert, which is templated in C++
-// data types. Used by fold_constant_convert, which determines the appropriate C++ type for "TI"
-// (input type).
-template <typename TI>
-shared_ptr<op::Constant> fold_constant_convert_helper0(shared_ptr<op::Constant> constant,
- const element::Type& output_element_type)
-{
-#if defined(__GNUC__) && !(__GNUC__ == 4 && __GNUC_MINOR__ == 8)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic error "-Wswitch"
-#pragma GCC diagnostic error "-Wswitch-enum"
-#endif
- switch (output_element_type)
- {
- case element::Type_t::undefined:
- NGRAPH_CHECK(false, "Encountered 'undefined' element type in fold_constant_convert");
- break;
- case element::Type_t::dynamic:
- NGRAPH_CHECK(false, "Encountered 'dynamic' element type in fold_constant_convert");
- break;
- case element::Type_t::u1:
- NGRAPH_CHECK(false, "Encountered 'dynamic' element type in fold_constant_convert");
- break;
- case element::Type_t::boolean:
- return fold_constant_convert_helper1<TI, char>(constant, output_element_type);
- case element::Type_t::bf16:
- return fold_constant_convert_helper1<TI, bfloat16>(constant, output_element_type);
- case element::Type_t::f16:
- return fold_constant_convert_helper1<TI, float16>(constant, output_element_type);
- case element::Type_t::f32:
- return fold_constant_convert_helper1<TI, float>(constant, output_element_type);
- case element::Type_t::f64:
- return fold_constant_convert_helper1<TI, double>(constant, output_element_type);
- case element::Type_t::i8:
- return fold_constant_convert_helper1<TI, int8_t>(constant, output_element_type);
- case element::Type_t::i16:
- return fold_constant_convert_helper1<TI, int16_t>(constant, output_element_type);
- case element::Type_t::i32:
- return fold_constant_convert_helper1<TI, int32_t>(constant, output_element_type);
- case element::Type_t::i64:
- return fold_constant_convert_helper1<TI, int64_t>(constant, output_element_type);
- case element::Type_t::u8:
- return fold_constant_convert_helper1<TI, uint8_t>(constant, output_element_type);
- case element::Type_t::u16:
- return fold_constant_convert_helper1<TI, uint16_t>(constant, output_element_type);
- case element::Type_t::u32:
- return fold_constant_convert_helper1<TI, uint32_t>(constant, output_element_type);
- case element::Type_t::u64:
- return fold_constant_convert_helper1<TI, uint64_t>(constant, output_element_type);
- }
-
- NGRAPH_UNREACHABLE("Unexpected switch case");
-#if defined(__GNUC__) && !(__GNUC__ == 4 && __GNUC_MINOR__ == 8)
-#pragma GCC diagnostic pop
-#endif
-}
-
-static shared_ptr<op::Constant> fold_constant_convert(shared_ptr<op::Constant> constant,
- const element::Type& output_element_type)
-{
- auto& input_element_type = constant->get_output_element_type(0);
-
- if (input_element_type == output_element_type)
- {
- return constant;
- }
-
-#if defined(__GNUC__) && !(__GNUC__ == 4 && __GNUC_MINOR__ == 8)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic error "-Wswitch"
-#pragma GCC diagnostic error "-Wswitch-enum"
-#endif
- switch (input_element_type)
- {
- case element::Type_t::undefined:
- NGRAPH_CHECK(false, "Encountered 'undefined' element type in fold_constant_convert");
- break;
- case element::Type_t::dynamic:
- NGRAPH_CHECK(false, "Encountered 'dynamic' element type in fold_constant_convert");
- break;
- case element::Type_t::u1:
- NGRAPH_CHECK(false, "Encountered 'u1' element type in fold_constant_convert");
- break;
- case element::Type_t::boolean:
- return fold_constant_convert_helper0<char>(constant, output_element_type);
- case element::Type_t::bf16:
- return fold_constant_convert_helper0<bfloat16>(constant, output_element_type);
- case element::Type_t::f16:
- return fold_constant_convert_helper0<float16>(constant, output_element_type);
- case element::Type_t::f32:
- return fold_constant_convert_helper0<float>(constant, output_element_type);
- case element::Type_t::f64:
- return fold_constant_convert_helper0<double>(constant, output_element_type);
- case element::Type_t::i8:
- return fold_constant_convert_helper0<int8_t>(constant, output_element_type);
- case element::Type_t::i16:
- return fold_constant_convert_helper0<int16_t>(constant, output_element_type);
- case element::Type_t::i32:
- return fold_constant_convert_helper0<int32_t>(constant, output_element_type);
- case element::Type_t::i64:
- return fold_constant_convert_helper0<int64_t>(constant, output_element_type);
- case element::Type_t::u8:
- return fold_constant_convert_helper0<uint8_t>(constant, output_element_type);
- case element::Type_t::u16:
- return fold_constant_convert_helper0<uint16_t>(constant, output_element_type);
- case element::Type_t::u32:
- return fold_constant_convert_helper0<uint32_t>(constant, output_element_type);
- case element::Type_t::u64:
- return fold_constant_convert_helper0<uint64_t>(constant, output_element_type);
- }
-
- NGRAPH_UNREACHABLE("Unexpected switch case");
-#if defined(__GNUC__) && !(__GNUC__ == 4 && __GNUC_MINOR__ == 8)
-#pragma GCC diagnostic pop
-#endif
-}
-
-void pass::ConstantFolding::construct_constant_convert()
-{
- auto constant_label = make_shared<pattern::op::Label>(
- element::i32, Shape{2, 3, 4}, pattern::has_class<op::Constant>());
- auto convert_op = make_shared<op::Convert>(constant_label, element::i64);
-
- auto constant_convert_callback = [this, constant_label](pattern::Matcher& m) {
- NGRAPH_DEBUG << "In callback for constant_convert_callback against node = "
- << m.get_match_root()->get_name();
-
- auto pattern_map = m.get_pattern_map();
-
- auto constant_match = static_pointer_cast<op::Constant>(pattern_map[constant_label]);
- auto convert_match = static_pointer_cast<op::Convert>(m.get_match_root());
-
- if (cf_is_disabled(convert_match))
- return false;
-
- NGRAPH_CHECK(revalidate_and_ensure_static(convert_match));
- auto const_node =
- fold_constant_convert(constant_match, convert_match->get_output_element_type(0));
- const_node->set_friendly_name(convert_match->get_friendly_name());
- replace_node(convert_match, const_node);
- copy_runtime_info_to_target_inputs(convert_match, const_node);
-
- return true;
- };
-
- auto convert_matcher =
- make_shared<pattern::Matcher>(convert_op, "ConstantFolding.ConstantConvert");
- NGRAPH_SUPPRESS_DEPRECATED_START
- this->add_matcher(
- convert_matcher, constant_convert_callback, PassProperty::CHANGE_DYNAMIC_STATE);
- NGRAPH_SUPPRESS_DEPRECATED_END
-}
+++ /dev/null
-//*****************************************************************************
-// Copyright 2017-2020 Intel Corporation
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//*****************************************************************************
-
-#include "constant_folding.hpp"
-#include "ngraph/log.hpp"
-#include "ngraph/op/concat.hpp"
-#include "ngraph/op/gather.hpp"
-#include "ngraph/op/squeeze.hpp"
-#include "ngraph/runtime/reference/gather.hpp"
-
-using namespace std;
-using namespace ngraph;
-
-void pass::ConstantFolding::construct_constant_gather_with_subgraph()
-{
- auto concat_label = make_shared<pattern::op::Label>(
- element::f32, Shape{2, 3, 4}, pattern::has_class<op::Concat>());
- auto indices_label =
- make_shared<pattern::op::Label>(element::i64, Shape{5}, pattern::has_class<op::Constant>());
- auto axis_label =
- make_shared<pattern::op::Label>(element::i64, Shape{1}, pattern::has_class<op::Constant>());
- auto gather_v1 = make_shared<op::v1::Gather>(concat_label, indices_label, axis_label);
-
- auto concat_gather_callback = [this, concat_label, indices_label, axis_label](
- pattern::Matcher& m) {
- NGRAPH_DEBUG << "In callback for construct_constant_gather_with_subgraph against node = "
- << m.get_match_root();
-
- auto pattern_map = m.get_pattern_map();
-
- const auto concat = static_pointer_cast<op::Concat>(pattern_map[concat_label]);
-
- const auto indices = static_pointer_cast<op::Constant>(pattern_map[indices_label]);
- const auto axis = static_pointer_cast<op::Constant>(pattern_map[axis_label]);
- const auto gather = m.get_match_root();
-
- if (cf_is_disabled(gather))
- return false;
-
- // only along axis=0
- if (axis->cast_vector<int64_t>()[0] != 0 || concat->get_axis() != 0)
- return false;
- // only single indices are accepted
- const auto indices_shape = indices->get_shape();
- if (indices_shape.size() > 1 || (indices_shape.size() == 1 && indices_shape[0] > 1))
- return false;
- // concat inputs are 1D and their count is equal to Concat output shape
- if (concat->get_output_partial_shape(0).is_dynamic())
- return false;
- const auto concat_inputs = concat->inputs();
- // concat inputs must be single elements
- if (concat_inputs.size() != shape_size(concat->get_shape()))
- return false;
-
- const int64_t rank = concat->get_shape()[0];
- const int64_t raw_index = indices->cast_vector<int64_t>()[0];
- const int64_t positive_index = raw_index < 0 ? rank + raw_index : raw_index;
- NGRAPH_CHECK(positive_index >= 0 && positive_index < rank);
-
- // gather takes exactly one element out of the Concat output
- const auto gathered_concat_input =
- concat_inputs[positive_index].get_source_output().get_node_shared_ptr();
- // Concat inputs are 1D, resulting tensor shape depends on Gather indices
- auto gathered = gathered_concat_input;
- if (indices_shape.empty())
- {
- // gathering a scalar
- auto axes = op::Constant::create(element::i64, Shape{1}, {0});
- gathered = make_shared<op::v0::Squeeze>(gathered_concat_input, axes);
- }
- gathered->set_friendly_name(gather->get_friendly_name());
- replace_node(gather, gathered);
- copy_runtime_info_to_target_inputs(gather, gathered);
- return true;
- };
-
- auto gather_matcher_v1 = make_shared<pattern::Matcher>(
- gather_v1, "ConstantFolding.ConstantGatherV1WithDynamicSubgraph");
- NGRAPH_SUPPRESS_DEPRECATED_START
- this->add_matcher(
- gather_matcher_v1, concat_gather_callback, PassProperty::CHANGE_DYNAMIC_STATE);
- NGRAPH_SUPPRESS_DEPRECATED_END
-}
+++ /dev/null
-//*****************************************************************************
-// Copyright 2017-2020 Intel Corporation
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//*****************************************************************************
-
-#include "constant_folding.hpp"
-#include "ngraph/log.hpp"
-#include "ngraph/op/reduce_logical_and.hpp"
-#include "ngraph/op/reduce_logical_or.hpp"
-#include "ngraph/runtime/reference/logical_reduction.hpp"
-
-NGRAPH_SUPPRESS_DEPRECATED_START
-
-using namespace std;
-using namespace ngraph;
-
-static shared_ptr<op::Constant> fold_constant_logical_reduction(shared_ptr<op::Constant> constant,
- shared_ptr<Node> reduction_node)
-{
- runtime::AlignedBuffer buffer(shape_size(reduction_node->get_shape()) * sizeof(char));
- char* data_ptr = buffer.get_ptr<char>();
-
- if (auto reduce_and = as_type_ptr<::ngraph::op::v1::ReduceLogicalAnd>(reduction_node))
- {
- const auto reduction_axes = reduce_and->get_reduction_axes();
- const auto input_shape = reduce_and->get_input_shape(0);
- const char* arg = constant->get_data_ptr<char>();
-
- runtime::reference::reduce_logical_and(
- arg, data_ptr, input_shape, reduction_axes, reduce_and->get_keep_dims());
- }
- else if (auto reduce_or = as_type_ptr<::ngraph::op::v1::ReduceLogicalOr>(reduction_node))
- {
- const auto reduction_axes = reduce_or->get_reduction_axes();
- const auto input_shape = reduce_or->get_input_shape(0);
- const char* arg = constant->get_data_ptr<char>();
-
- runtime::reference::reduce_logical_or(
- arg, data_ptr, input_shape, reduction_axes, reduce_or->get_keep_dims());
- }
- else
- {
- NGRAPH_CHECK(false,
- "Internal nGraph error: Ops handled in "
- "fold_constant_logical_reduction must be consistent with those "
- "matched in construct_constant_logical_reduction");
- }
-
- return make_shared<op::Constant>(
- reduction_node->get_output_element_type(0), reduction_node->get_shape(), data_ptr);
-}
-
-void pass::ConstantFolding::construct_constant_logical_reduction()
-{
- auto constant_data_label = make_shared<pattern::op::Label>(
- element::boolean, Shape{2, 3, 4}, pattern::has_class<op::Constant>());
- auto constant_axes_label =
- make_shared<pattern::op::Label>(element::i64, Shape{2}, pattern::has_class<op::Constant>());
- auto is_supported_reduction = [](std::shared_ptr<Node> n) {
- return pattern::has_class<::ngraph::op::v1::ReduceLogicalAnd>()(n) ||
- pattern::has_class<::ngraph::op::v1::ReduceLogicalOr>()(n);
- };
- auto reduction =
- std::make_shared<pattern::op::Any>(element::i32,
- Shape{2},
- is_supported_reduction,
- NodeVector{constant_data_label, constant_axes_label});
-
- auto constant_logical_reduction_callback = [this, constant_data_label](pattern::Matcher& m) {
- NGRAPH_DEBUG << "In callback for constant_logical_reduction_callback against node = "
- << m.get_match_root()->get_name();
-
- auto pattern_map = m.get_pattern_map();
-
- auto constant_match = static_pointer_cast<op::Constant>(pattern_map[constant_data_label]);
- auto reduction_match = m.get_match_root();
-
- if (cf_is_disabled(reduction_match))
- return false;
-
- NGRAPH_CHECK(revalidate_and_ensure_static(reduction_match));
- auto const_node = fold_constant_logical_reduction(constant_match, reduction_match);
- const_node->set_friendly_name(reduction_match->get_friendly_name());
- replace_node(reduction_match, const_node);
- copy_runtime_info_to_target_inputs(reduction_match, const_node);
- return true;
- };
-
- auto logical_reduction_matcher =
- make_shared<pattern::Matcher>(reduction, "ConstantFolding.ConstantLogicalReduction");
- NGRAPH_SUPPRESS_DEPRECATED_START
- this->add_matcher(logical_reduction_matcher,
- constant_logical_reduction_callback,
- PassProperty::CHANGE_DYNAMIC_STATE);
- NGRAPH_SUPPRESS_DEPRECATED_END
-}
+++ /dev/null
-//*****************************************************************************
-// Copyright 2017-2020 Intel Corporation
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//*****************************************************************************
-
-#include "constant_folding.hpp"
-#include "ngraph/log.hpp"
-#include "ngraph/op/constant.hpp"
-#include "ngraph/op/one_hot.hpp"
-#include "ngraph/runtime/reference/broadcast.hpp"
-#include "ngraph/runtime/reference/one_hot.hpp"
-
-using namespace std;
-using namespace ngraph;
-
-template <class INDICES_TYPE, class OUTPUT_TYPE>
-shared_ptr<op::Constant> fold_constant_one_hot_ref(const shared_ptr<op::Constant>& indices,
- const shared_ptr<op::Constant>& on_value,
- const shared_ptr<op::Constant>& off_value,
- const Shape& output_shape,
- size_t axis)
-{
- std::vector<OUTPUT_TYPE> out_vec(shape_size(output_shape));
- runtime::reference::one_hot<INDICES_TYPE, OUTPUT_TYPE>(
- indices->get_data_ptr<INDICES_TYPE>(),
- out_vec.data(),
- indices->get_shape(),
- output_shape,
- axis,
- on_value->get_data_ptr<OUTPUT_TYPE>()[0],
- off_value->get_data_ptr<OUTPUT_TYPE>()[0]);
-
- return make_shared<op::Constant>(on_value->get_element_type(), output_shape, out_vec);
-}
-
-template <class OUTPUT_TYPE>
-shared_ptr<op::Constant> fold_constant_one_hot(const shared_ptr<op::Constant>& indices,
- const shared_ptr<op::Constant>& on_value,
- const shared_ptr<op::Constant>& off_value,
- const Shape& output_shape,
- size_t axis)
-{
- shared_ptr<op::Constant> rc;
- switch (indices->get_element_type())
- {
- case element::Type_t::undefined:
- case element::Type_t::dynamic:
- case element::Type_t::u1:
- case element::Type_t::boolean:
- case element::Type_t::bf16:
- case element::Type_t::f16:
- case element::Type_t::f32:
- case element::Type_t::f64:
- NGRAPH_CHECK(false, "Indices input element type must be integer");
- break;
- case element::Type_t::i8:
- rc = fold_constant_one_hot_ref<int8_t, OUTPUT_TYPE>(
- indices, on_value, off_value, output_shape, axis);
- break;
- case element::Type_t::i16:
- rc = fold_constant_one_hot_ref<int16_t, OUTPUT_TYPE>(
- indices, on_value, off_value, output_shape, axis);
- break;
- case element::Type_t::i32:
- rc = fold_constant_one_hot_ref<int32_t, OUTPUT_TYPE>(
- indices, on_value, off_value, output_shape, axis);
- break;
- case element::Type_t::i64:
- rc = fold_constant_one_hot_ref<int64_t, OUTPUT_TYPE>(
- indices, on_value, off_value, output_shape, axis);
- break;
- case element::Type_t::u8:
- rc = fold_constant_one_hot_ref<uint8_t, OUTPUT_TYPE>(
- indices, on_value, off_value, output_shape, axis);
- break;
- case element::Type_t::u16:
- rc = fold_constant_one_hot_ref<uint16_t, OUTPUT_TYPE>(
- indices, on_value, off_value, output_shape, axis);
- break;
- case element::Type_t::u32:
- rc = fold_constant_one_hot_ref<uint32_t, OUTPUT_TYPE>(
- indices, on_value, off_value, output_shape, axis);
- break;
- case element::Type_t::u64:
- rc = fold_constant_one_hot_ref<uint64_t, OUTPUT_TYPE>(
- indices, on_value, off_value, output_shape, axis);
- break;
- default: NGRAPH_CHECK(false, "Indices input element type must be integer");
- }
- return rc;
-}
-
-void pass::ConstantFolding::construct_constant_one_hot()
-{
- auto indices_label =
- make_shared<pattern::op::Label>(element::i64, Shape{3}, pattern::has_class<op::Constant>());
- auto depth_label =
- make_shared<pattern::op::Label>(element::i64, Shape{}, pattern::has_class<op::Constant>());
- auto on_label =
- make_shared<pattern::op::Label>(element::i64, Shape{}, pattern::has_class<op::Constant>());
- auto off_label =
- make_shared<pattern::op::Label>(element::i64, Shape{}, pattern::has_class<op::Constant>());
- int64_t axis = 0;
- auto ont_hot_pattern =
- make_shared<op::v1::OneHot>(indices_label, depth_label, on_label, off_label, axis);
-
- auto one_hot_callback = [this, indices_label, depth_label, on_label, off_label](
- pattern::Matcher& m) {
- NGRAPH_DEBUG << "In callback for one_hot_callback against node = "
- << m.get_match_root()->get_name();
- auto pattern_map = m.get_pattern_map();
-
- auto indices_node = static_pointer_cast<op::Constant>(pattern_map[indices_label]);
- const auto depth_node = static_pointer_cast<op::Constant>(pattern_map[depth_label]);
- const auto on_node = static_pointer_cast<op::Constant>(pattern_map[on_label]);
- const auto off_node = static_pointer_cast<op::Constant>(pattern_map[off_label]);
-
- auto one_hot = static_pointer_cast<op::v1::OneHot>(m.get_match_root());
-
- if (cf_is_disabled(one_hot))
- return false;
-
- const size_t axis = one_hot->get_axis();
- const auto output_shape = one_hot->get_output_shape(0);
- auto output_type = on_node->get_element_type();
-
- std::shared_ptr<op::Constant> replacement =
- fold_constant_one_hot<char>(indices_node, on_node, off_node, output_shape, axis);
- switch (output_type)
- {
- case element::Type_t::undefined:
- NGRAPH_CHECK(false, "Encountered 'undefined' element type in one_hot_callback");
- break;
- case element::Type_t::dynamic:
- NGRAPH_CHECK(false, "Encountered 'dynamic' element type in one_hot_callback");
- break;
- case element::Type_t::u1:
- NGRAPH_CHECK(false, "Encountered 'u1' element type in one_hot_callback");
- break;
- case element::Type_t::boolean:
- replacement =
- fold_constant_one_hot<char>(indices_node, on_node, off_node, output_shape, axis);
- break;
- case element::Type_t::bf16:
- replacement = fold_constant_one_hot<bfloat16>(
- indices_node, on_node, off_node, output_shape, axis);
- break;
- case element::Type_t::f16:
- replacement =
- fold_constant_one_hot<float16>(indices_node, on_node, off_node, output_shape, axis);
- break;
- case element::Type_t::f32:
- replacement =
- fold_constant_one_hot<float>(indices_node, on_node, off_node, output_shape, axis);
- break;
- case element::Type_t::f64:
- replacement =
- fold_constant_one_hot<double>(indices_node, on_node, off_node, output_shape, axis);
- break;
- case element::Type_t::i8:
- replacement =
- fold_constant_one_hot<int8_t>(indices_node, on_node, off_node, output_shape, axis);
- break;
- case element::Type_t::i16:
- replacement =
- fold_constant_one_hot<int16_t>(indices_node, on_node, off_node, output_shape, axis);
- break;
- case element::Type_t::i32:
- replacement =
- fold_constant_one_hot<int32_t>(indices_node, on_node, off_node, output_shape, axis);
- break;
- case element::Type_t::i64:
- replacement =
- fold_constant_one_hot<int64_t>(indices_node, on_node, off_node, output_shape, axis);
- break;
- case element::Type_t::u8:
- replacement =
- fold_constant_one_hot<uint8_t>(indices_node, on_node, off_node, output_shape, axis);
- break;
- case element::Type_t::u16:
- replacement = fold_constant_one_hot<uint16_t>(
- indices_node, on_node, off_node, output_shape, axis);
- break;
- case element::Type_t::u32:
- replacement = fold_constant_one_hot<uint32_t>(
- indices_node, on_node, off_node, output_shape, axis);
- break;
- case element::Type_t::u64:
- replacement = fold_constant_one_hot<uint64_t>(
- indices_node, on_node, off_node, output_shape, axis);
- break;
- }
- replacement->set_friendly_name(m.get_match_root()->get_friendly_name());
- replace_node(m.get_match_root(), replacement);
- copy_runtime_info_to_target_inputs(m.get_match_root(), replacement);
- return true;
- };
- auto one_hot_matcher =
- make_shared<pattern::Matcher>(ont_hot_pattern, "ConstantFolding.ConstantOneHot");
- NGRAPH_SUPPRESS_DEPRECATED_START
- this->add_matcher(one_hot_matcher, one_hot_callback, PassProperty::CHANGE_DYNAMIC_STATE);
- NGRAPH_SUPPRESS_DEPRECATED_END
-}
+++ /dev/null
-//*****************************************************************************
-// Copyright 2017-2020 Intel Corporation
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//*****************************************************************************
-
-#include "constant_folding.hpp"
-#include "ngraph/log.hpp"
-#include "ngraph/op/quantize.hpp"
-#include "ngraph/runtime/reference/quantize.hpp"
-
-NGRAPH_SUPPRESS_DEPRECATED_START
-
-using namespace std;
-using namespace ngraph;
-
-template <class REAL, class QUANT>
-shared_ptr<op::Constant> fold_constant_quantize(shared_ptr<op::Constant> constant,
- shared_ptr<op::Quantize> quant,
- shared_ptr<op::Constant> scale,
- shared_ptr<op::Constant> offset)
-{
- const Shape& out_shape = constant->get_shape();
- runtime::AlignedBuffer buffer(shape_size(out_shape) * sizeof(QUANT));
- QUANT* data_ptr = buffer.get_ptr<QUANT>();
-
- runtime::reference::quantize<REAL, QUANT>(constant->get_data_ptr<REAL>(),
- scale->get_data_ptr<REAL>(),
- offset->get_data_ptr<QUANT>(),
- data_ptr,
- constant->get_shape(),
- scale->get_shape(),
- quant->get_axes(),
- quant->get_round_mode());
-
- return make_shared<op::Constant>(quant->get_element_type(), out_shape, data_ptr);
-}
-
-void pass::ConstantFolding::construct_constant_quantize()
-{
- auto constant_label =
- make_shared<pattern::op::Label>(element::f32, Shape{2}, pattern::has_class<op::Constant>());
- auto q_scale = op::Constant::create(element::f32, Shape{}, {1});
- auto q_offset = op::Constant::create(element::i8, Shape{}, {0});
- auto mode = op::Quantize::RoundMode::ROUND_NEAREST_TOWARD_INFINITY;
- auto quant_op =
- make_shared<op::Quantize>(constant_label, q_scale, q_offset, element::i8, AxisSet{}, mode);
- auto quant = make_shared<pattern::op::Label>(quant_op, nullptr, NodeVector{quant_op});
-
- auto constant_quantize_callback = [this, constant_label, quant](pattern::Matcher& m) {
- NGRAPH_DEBUG << "In callback for constant_quantize_callback against node = "
- << m.get_match_root()->get_name();
-
- auto pattern_map = m.get_pattern_map();
-
- auto constant_match = as_type_ptr<op::Constant>(pattern_map[constant_label]);
- auto quant_match = pattern_map[quant];
- auto quantize_op = as_type_ptr<op::Quantize>(quant_match);
-
- if (cf_is_disabled(quantize_op))
- return false;
-
- NGRAPH_CHECK(revalidate_and_ensure_static(quantize_op));
-
- auto scale = static_pointer_cast<op::Constant>(quant_match->get_input_node_shared_ptr(1));
- auto offset = static_pointer_cast<op::Constant>(quant_match->get_input_node_shared_ptr(2));
-
- auto type = quant_match->get_element_type();
-
- if (constant_match->get_element_type() != element::f32)
- {
- return false;
- }
-
- if (type == element::u8)
- {
- auto const_node =
- fold_constant_quantize<float, uint8_t>(constant_match, quantize_op, scale, offset);
- const_node->set_friendly_name(m.get_match_root()->get_friendly_name());
- replace_node(m.get_match_root(), const_node);
- copy_runtime_info_to_target_inputs(m.get_match_root(), const_node);
- return true;
- }
- else if (type == element::i8)
- {
- auto const_node =
- fold_constant_quantize<float, int8_t>(constant_match, quantize_op, scale, offset);
- const_node->set_friendly_name(m.get_match_root()->get_friendly_name());
- replace_node(m.get_match_root(), const_node);
- copy_runtime_info_to_target_inputs(m.get_match_root(), const_node);
- return true;
- }
-
- return false;
- };
-
- auto quantize_matcher =
- make_shared<pattern::Matcher>(quant, "ConstantFolding.ConstantQuantize");
- NGRAPH_SUPPRESS_DEPRECATED_START
- this->add_matcher(
- quantize_matcher, constant_quantize_callback, PassProperty::CHANGE_DYNAMIC_STATE);
- NGRAPH_SUPPRESS_DEPRECATED_END
-}
+++ /dev/null
-//*****************************************************************************
-// Copyright 2017-2020 Intel Corporation
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//*****************************************************************************
-
-#include "constant_folding.hpp"
-#include "ngraph/log.hpp"
-#include "ngraph/op/scatter_elements_update.hpp"
-#include "ngraph/runtime/reference/scatter_elements_update.hpp"
-#include "ngraph/validation_util.hpp"
-
-using namespace std;
-using namespace ngraph;
-
-template <typename DataType, typename IndicesType, typename AxisType>
-static shared_ptr<op::Constant>
- fold_constant_scatter_elem_updt(const shared_ptr<op::Constant>& data,
- const shared_ptr<op::Constant>& indices,
- const shared_ptr<op::Constant>& updates,
- const shared_ptr<op::Constant>& axis,
- const shared_ptr<Node>& scatter)
-{
- runtime::AlignedBuffer buffer(shape_size(scatter->get_shape()) * sizeof(DataType));
- DataType* data_ptr = buffer.get_ptr<DataType>();
-
- if (is_type<op::v3::ScatterElementsUpdate>(scatter))
- {
- int64_t normalized_axis = normalize_axis(scatter.get(),
- *(axis->get_data_ptr<AxisType>()),
- static_cast<int64_t>(data->get_shape().size()));
-
- runtime::reference::scatter_elem_update<DataType, IndicesType>(
- data->get_data_ptr<DataType>(),
- indices->get_data_ptr<IndicesType>(),
- updates->get_data_ptr<DataType>(),
- normalized_axis,
- data_ptr,
- data->get_shape(),
- indices->get_shape());
- }
- else
- {
- throw ngraph_error("Unsupported op in scatter_elem_updt constant folding.");
- }
-
- return make_shared<op::Constant>(
- scatter->get_output_element_type(0), scatter->get_output_shape(0), data_ptr);
-}
-
-template <typename T, typename U>
-static shared_ptr<op::Constant>
- dispatch_const_fold_indices(const shared_ptr<op::Constant>& data,
- const shared_ptr<op::Constant>& indices,
- const shared_ptr<op::Constant>& updates,
- const shared_ptr<op::Constant>& axis,
- const shared_ptr<Node>& scatter_elem_updt)
-{
- auto axis_type = axis->get_output_element_type(0);
-
- // Dispatch specialization based on axis data type.
- switch (axis_type)
- {
- case element::Type_t::undefined:
- NGRAPH_CHECK(false,
- "Encountered 'undefined' element type in constant_scatter_elem_updt_callback");
- break;
- case element::Type_t::dynamic:
- NGRAPH_CHECK(false,
- "Encountered 'dynamic' element type in constant_scatter_elem_updt_callback");
- break;
- case element::Type_t::u8:
- case element::Type_t::i8:
- return fold_constant_scatter_elem_updt<T, U, uint8_t>(
- data, indices, updates, axis, scatter_elem_updt);
- case element::Type_t::u16:
- case element::Type_t::i16:
- return fold_constant_scatter_elem_updt<T, U, uint16_t>(
- data, indices, updates, axis, scatter_elem_updt);
- case element::Type_t::u32:
- case element::Type_t::i32:
- return fold_constant_scatter_elem_updt<T, U, uint32_t>(
- data, indices, updates, axis, scatter_elem_updt);
- case element::Type_t::u64:
- case element::Type_t::i64:
- return fold_constant_scatter_elem_updt<T, U, uint64_t>(
- data, indices, updates, axis, scatter_elem_updt);
- case element::Type_t::boolean:
- case element::Type_t::bf16:
- case element::Type_t::f16:
- case element::Type_t::f32:
- case element::Type_t::f64:
- case element::Type_t::u1:
- default: break;
- }
-
- NGRAPH_CHECK(
- false,
- "Encountered unsupported axis element type in constant_scatter_elem_updt_callback: ",
- axis_type);
-}
-
-template <typename T>
-static shared_ptr<op::Constant> dispatch_const_fold_data(const shared_ptr<op::Constant>& data,
- const shared_ptr<op::Constant>& indices,
- const shared_ptr<op::Constant>& updates,
- const shared_ptr<op::Constant>& axis,
- const shared_ptr<Node>& scatter_elem_updt)
-{
- auto indices_type = indices->get_output_element_type(0);
-
- // Dispatch specialization based on indicies data type.
- switch (indices_type)
- {
- case element::Type_t::undefined:
- NGRAPH_CHECK(false,
- "Encountered 'undefined' element type in constant_scatter_elem_updt_callback");
- break;
- case element::Type_t::dynamic:
- NGRAPH_CHECK(false,
- "Encountered 'dynamic' element type in constant_scatter_elem_updt_callback");
- break;
- case element::Type_t::u8:
- case element::Type_t::i8:
- return dispatch_const_fold_indices<T, uint8_t>(
- data, indices, updates, axis, scatter_elem_updt);
- case element::Type_t::u16:
- case element::Type_t::i16:
- return dispatch_const_fold_indices<T, uint16_t>(
- data, indices, updates, axis, scatter_elem_updt);
- case element::Type_t::u32:
- case element::Type_t::i32:
- return dispatch_const_fold_indices<T, uint32_t>(
- data, indices, updates, axis, scatter_elem_updt);
- case element::Type_t::u64:
- case element::Type_t::i64:
- return dispatch_const_fold_indices<T, uint64_t>(
- data, indices, updates, axis, scatter_elem_updt);
- case element::Type_t::boolean:
- case element::Type_t::bf16:
- case element::Type_t::f16:
- case element::Type_t::f32:
- case element::Type_t::f64:
- case element::Type_t::u1:
- default: break;
- }
-
- NGRAPH_CHECK(
- false,
- "Encountered unsupported indices element type in constant_scatter_elem_updt_callback: ",
- indices_type);
-}
-
-void pass::ConstantFolding::construct_constant_scatter_elements_update()
-{
- const auto data_label = make_shared<pattern::op::Label>(
- element::f32, Shape{10, 20, 30}, pattern::has_class<op::Constant>());
- const auto indices_label = make_shared<pattern::op::Label>(
- element::i64, Shape{5, 10, 15}, pattern::has_class<op::Constant>());
- const auto updates_label = make_shared<pattern::op::Label>(
- element::f32, Shape{5, 10, 15}, pattern::has_class<op::Constant>());
- const auto axis_label =
- make_shared<pattern::op::Label>(element::i64, Shape{}, pattern::has_class<op::Constant>());
- auto scatter_elem_updt = make_shared<op::v3::ScatterElementsUpdate>(
- data_label, indices_label, updates_label, axis_label);
-
- auto constant_scatter_elem_updt_callback = [this,
- data_label,
- indices_label,
- updates_label,
- axis_label](pattern::Matcher& m) {
- NGRAPH_DEBUG << "In callback for constant_scatter_elem_updt_callback against node = "
- << m.get_match_root()->get_name();
-
- auto pattern_map = m.get_pattern_map();
-
- const auto data = static_pointer_cast<op::Constant>(pattern_map[data_label]);
- const auto indices = static_pointer_cast<op::Constant>(pattern_map[indices_label]);
- const auto updates = static_pointer_cast<op::Constant>(pattern_map[updates_label]);
- const auto axis = static_pointer_cast<op::Constant>(pattern_map[axis_label]);
- const auto scatter_elem_updt = m.get_match_root();
-
- if (cf_is_disabled(scatter_elem_updt))
- return false;
-
- NGRAPH_CHECK(revalidate_and_ensure_static(scatter_elem_updt));
-
- std::shared_ptr<Node> replacement;
- const auto data_type = data->get_output_element_type(0);
- NGRAPH_CHECK(data_type == updates->get_output_element_type(0),
- "data input and updates element type must be equal. Got data type: ",
- data_type,
- ", updates type: ",
- updates->get_output_element_type(0));
-
- // Dispatch specialization based on data and updates type
- switch (data_type)
- {
- case element::Type_t::undefined:
- NGRAPH_CHECK(
- false,
- "Encountered 'undefined' element type in constant_scatter_elem_updt_callback");
- break;
- case element::Type_t::dynamic:
- NGRAPH_CHECK(
- false, "Encountered 'dynamic' element type in constant_scatter_elem_updt_callback");
- break;
- case element::Type_t::boolean:
- NGRAPH_CHECK(
- false, "Encountered 'boolean' element type in constant_scatter_elem_updt_callback");
- break;
- case element::Type_t::u1:
- NGRAPH_CHECK(false,
- "Encountered 'u1' element type in constant_scatter_elem_updt_callback");
- break;
- case element::Type_t::bf16:
- case element::Type_t::f16:
- replacement =
- dispatch_const_fold_data<float16>(data, indices, updates, axis, scatter_elem_updt);
- break;
- case element::Type_t::f32:
- replacement =
- dispatch_const_fold_data<float>(data, indices, updates, axis, scatter_elem_updt);
- break;
- case element::Type_t::f64:
- replacement =
- dispatch_const_fold_data<double>(data, indices, updates, axis, scatter_elem_updt);
- break;
- case element::Type_t::u8:
- case element::Type_t::i8:
- replacement =
- dispatch_const_fold_data<uint8_t>(data, indices, updates, axis, scatter_elem_updt);
- break;
- case element::Type_t::u16:
- case element::Type_t::i16:
- replacement =
- dispatch_const_fold_data<uint16_t>(data, indices, updates, axis, scatter_elem_updt);
- break;
- case element::Type_t::u32:
- case element::Type_t::i32:
- replacement =
- dispatch_const_fold_data<uint32_t>(data, indices, updates, axis, scatter_elem_updt);
- break;
- case element::Type_t::u64:
- case element::Type_t::i64:
- replacement =
- dispatch_const_fold_data<uint64_t>(data, indices, updates, axis, scatter_elem_updt);
- break;
- default:
- NGRAPH_CHECK(
- false, "Encountered unhandled element type in constant_scatter_elem_updt_callback");
- break;
- }
-
- replacement->set_friendly_name(m.get_match_root()->get_friendly_name());
- replace_node(m.get_match_root(), replacement);
- copy_runtime_info_to_target_inputs(m.get_match_root(), replacement);
- return true;
- };
-
- auto scatter_elem_updt_matcher = make_shared<pattern::Matcher>(
- scatter_elem_updt, "ConstantFolding.ConstantScatterElementsUpdateV3");
- NGRAPH_SUPPRESS_DEPRECATED_START
- this->add_matcher(scatter_elem_updt_matcher,
- constant_scatter_elem_updt_callback,
- PassProperty::CHANGE_DYNAMIC_STATE);
- NGRAPH_SUPPRESS_DEPRECATED_END
-}
+++ /dev/null
-//*****************************************************************************
-// Copyright 2017-2020 Intel Corporation
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//*****************************************************************************
-
-#include "constant_folding.hpp"
-#include "ngraph/log.hpp"
-#include "ngraph/op/select.hpp"
-#include "ngraph/runtime/reference/select.hpp"
-
-NGRAPH_SUPPRESS_DEPRECATED_START
-
-using namespace std;
-using namespace ngraph;
-
-template <class T>
-shared_ptr<op::Constant> fold_constant_select(const shared_ptr<op::Constant>& selection,
- const shared_ptr<op::Constant>& t,
- const shared_ptr<op::Constant>& f,
- const shared_ptr<Node>& select)
-{
- const Shape& out_shape = select->get_shape();
- runtime::AlignedBuffer buffer(shape_size(out_shape) * sizeof(T));
- T* data_ptr = buffer.get_ptr<T>();
-
- if (auto select_v0 = as_type_ptr<op::v0::Select>(select))
- {
- runtime::reference::select<T>(selection->get_data_ptr<char>(),
- t->get_data_ptr<T>(),
- f->get_data_ptr<T>(),
- data_ptr,
- shape_size(out_shape));
- }
- else if (auto select_v1 = as_type_ptr<op::v1::Select>(select))
- {
- runtime::reference::select<T>(selection->get_data_ptr<char>(),
- t->get_data_ptr<T>(),
- f->get_data_ptr<T>(),
- data_ptr,
- selection->get_shape(),
- t->get_shape(),
- f->get_shape(),
- select_v1->get_auto_broadcast());
- }
-
- return make_shared<op::Constant>(select->get_element_type(), out_shape, data_ptr);
-}
-
-void pass::ConstantFolding::construct_constant_select()
-{
- auto selection_label = make_shared<pattern::op::Label>(
- element::boolean, Shape{2, 3, 4}, pattern::has_class<op::Constant>());
- auto t_label = make_shared<pattern::op::Label>(
- element::i64, Shape{2, 3, 4}, pattern::has_class<op::Constant>());
- auto f_label = make_shared<pattern::op::Label>(
- element::i64, Shape{2, 3, 4}, pattern::has_class<op::Constant>());
- auto select_v0_op = make_shared<op::v0::Select>(selection_label, t_label, f_label);
- auto select_v1_op = make_shared<op::v1::Select>(selection_label, t_label, f_label);
-
- auto constant_select_callback = [this, selection_label, t_label, f_label](pattern::Matcher& m) {
- NGRAPH_DEBUG << "In callback for constant_select_callback against node = "
- << m.get_match_root()->get_name();
-
- auto pattern_map = m.get_pattern_map();
-
- const auto& selection_node =
- static_pointer_cast<op::Constant>(pattern_map[selection_label]);
- const auto& t_node = static_pointer_cast<op::Constant>(pattern_map[t_label]);
- const auto& f_node = static_pointer_cast<op::Constant>(pattern_map[f_label]);
- const auto& select = m.get_match_root();
-
- if (cf_is_disabled(select))
- return false;
-
- NGRAPH_CHECK(revalidate_and_ensure_static(select));
-
- std::shared_ptr<op::Constant> replacement;
-
- switch (select->get_output_element_type(0))
- {
- case element::Type_t::undefined:
- NGRAPH_CHECK(false, "Encountered 'undefined' element type in constant_select_callback");
- break;
- case element::Type_t::dynamic:
- NGRAPH_CHECK(false, "Encountered 'dynamic' element type in constant_select_callback");
- break;
- case element::Type_t::u1:
- NGRAPH_CHECK(false, "Encountered 'u1' element type in constant_select_callback");
- break;
- case element::Type_t::boolean:
- replacement = fold_constant_select<char>(selection_node, t_node, f_node, select);
- break;
- case element::Type_t::bf16:
- replacement = fold_constant_select<bfloat16>(selection_node, t_node, f_node, select);
- break;
- case element::Type_t::f16:
- replacement = fold_constant_select<float16>(selection_node, t_node, f_node, select);
- break;
- case element::Type_t::f32:
- replacement = fold_constant_select<float>(selection_node, t_node, f_node, select);
- break;
- case element::Type_t::f64:
- replacement = fold_constant_select<double>(selection_node, t_node, f_node, select);
- break;
- case element::Type_t::i8:
- replacement = fold_constant_select<int8_t>(selection_node, t_node, f_node, select);
- break;
- case element::Type_t::i16:
- replacement = fold_constant_select<int16_t>(selection_node, t_node, f_node, select);
- break;
- case element::Type_t::i32:
- replacement = fold_constant_select<int32_t>(selection_node, t_node, f_node, select);
- break;
- case element::Type_t::i64:
- replacement = fold_constant_select<int64_t>(selection_node, t_node, f_node, select);
- break;
- case element::Type_t::u8:
- replacement = fold_constant_select<uint8_t>(selection_node, t_node, f_node, select);
- break;
- case element::Type_t::u16:
- replacement = fold_constant_select<uint16_t>(selection_node, t_node, f_node, select);
- break;
- case element::Type_t::u32:
- replacement = fold_constant_select<uint32_t>(selection_node, t_node, f_node, select);
- break;
- case element::Type_t::u64:
- replacement = fold_constant_select<uint64_t>(selection_node, t_node, f_node, select);
- break;
- }
-
- replacement->set_friendly_name(m.get_match_root()->get_friendly_name());
- replace_node(m.get_match_root(), replacement);
- copy_runtime_info_to_target_inputs(m.get_match_root(), replacement);
- return true;
- };
-
- NGRAPH_SUPPRESS_DEPRECATED_START
- this->add_matcher(
- make_shared<pattern::Matcher>(select_v0_op, "ConstantFolding.ConstantSelectV0"),
- constant_select_callback,
- PassProperty::CHANGE_DYNAMIC_STATE);
- this->add_matcher(
- make_shared<pattern::Matcher>(select_v1_op, "ConstantFolding.ConstantSelectV1"),
- constant_select_callback,
- PassProperty::CHANGE_DYNAMIC_STATE);
- NGRAPH_SUPPRESS_DEPRECATED_END
-}
ASSERT_NO_THROW(pass_manager.run_passes(func_error));
}
-TEST(constant_folding, const_quantize)
-{
- Shape input_shape{12};
- Shape scale_offset_shape;
- AxisSet quantization_axes;
-
- auto quant_type = element::u8;
- auto output_type = element::u8;
- typedef uint8_t output_c_type;
-
- vector<float> values_in{1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0, 5.0, 5.0, 6.0, 6.0, 7.0};
- auto constant = op::Constant::create(element::f32, input_shape, values_in);
- auto scale = op::Constant::create(element::f32, scale_offset_shape, {2});
- auto offset = op::Constant::create(quant_type, scale_offset_shape, {1});
- auto mode = op::Quantize::RoundMode::ROUND_NEAREST_TOWARD_INFINITY;
- auto quantize =
- make_shared<op::Quantize>(constant, scale, offset, output_type, quantization_axes, mode);
- quantize->set_friendly_name("test");
- auto f = make_shared<Function>(quantize, ParameterVector{});
-
- pass::Manager pass_manager;
- pass_manager.register_pass<pass::ConstantFolding>();
- pass_manager.run_passes(f);
-
- ASSERT_EQ(count_ops_of_type<op::Quantize>(f), 0);
- ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
-
- auto new_const =
- as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
- ASSERT_TRUE(new_const);
- ASSERT_EQ(new_const->get_friendly_name(), "test");
- auto values_out = new_const->get_vector<output_c_type>();
-
- vector<output_c_type> values_quantize{2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5};
- ASSERT_EQ(values_quantize, values_out);
-}
-
TEST(constant_folding, const_convert)
{
Shape input_shape{3, 4};
range_test<float>(12, 4, -2, {12, 10, 8, 6});
}
-TEST(constant_folding, constant_select)
-{
- Shape shape{2, 4};
- vector<char> values_selection{0, 1, 1, 0, 1, 0, 0, 1};
- vector<int64_t> values_t{2, 4, 6, 8, 10, 12, 14, 16};
- vector<int64_t> values_f{1, 3, 5, 7, 9, 11, 13, 15};
-
- auto constant_selection = make_shared<op::Constant>(element::boolean, shape, values_selection);
- auto constant_t = make_shared<op::Constant>(element::i64, shape, values_t);
- auto constant_f = make_shared<op::Constant>(element::i64, shape, values_f);
- auto select = make_shared<op::Select>(constant_selection, constant_t, constant_f);
- select->set_friendly_name("test");
- auto f = make_shared<Function>(select, ParameterVector{});
-
- pass::Manager pass_manager;
- pass_manager.register_pass<pass::ConstantFolding>();
- pass_manager.run_passes(f);
-
- ASSERT_EQ(count_ops_of_type<op::Select>(f), 0);
- ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
-
- auto new_const =
- as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
- ASSERT_TRUE(new_const);
- ASSERT_EQ(new_const->get_friendly_name(), "test");
- auto values_out = new_const->get_vector<int64_t>();
-
- vector<int64_t> values_expected{1, 4, 6, 7, 10, 11, 13, 16};
- ASSERT_EQ(values_expected, values_out);
-}
-
TEST(constant_folding, constant_v1_select)
{
Shape shape{2, 4};
TEST(constant_folding, constant_v1_one_hot)
{
- vector<int64_t> indices{0, 1, 2};
- float16 on_value = 1.123f;
- float16 off_value = 0.321f;
+ const vector<int64_t> indices{0, 1, 2};
+ const float on_value = 1.123f;
+ const float off_value = 0.321f;
const auto indices_const = op::Constant::create(element::i64, Shape{3}, indices);
const auto depth_const = op::Constant::create(element::i64, Shape{}, {3});
- const auto on_const = op::Constant::create(element::f16, Shape{}, {on_value});
- const auto off_const = op::Constant::create(element::f16, Shape{}, {off_value});
+ const auto on_const = op::Constant::create(element::f32, Shape{}, {on_value});
+ const auto off_const = op::Constant::create(element::f32, Shape{}, {off_value});
int64_t axis = 1;
auto one_hot_v1 =
ASSERT_TRUE(res);
ASSERT_EQ((Shape{3, 3}), res->get_output_shape(0));
- ASSERT_EQ(vector<float16>({on_value,
- off_value,
- off_value,
- off_value,
- on_value,
- off_value,
- off_value,
- off_value,
- on_value}),
- res->get_vector<float16>());
+ ASSERT_EQ(vector<float>({on_value,
+ off_value,
+ off_value,
+ off_value,
+ on_value,
+ off_value,
+ off_value,
+ off_value,
+ on_value}),
+ res->get_vector<float>());
}
TEST(constant_folding, constant_v1_one_hot_negative_axes)
{
- vector<int64_t> indices{0, 2, -1, 1};
- int16_t on_value = 4;
- int16_t off_value = 1;
+ const vector<int64_t> indices{0, 2, -1, 1};
+ const int32_t on_value = 4;
+ const int32_t off_value = 1;
const auto indices_const = op::Constant::create(element::i64, Shape{4}, indices);
const auto depth_const = op::Constant::create(element::i64, Shape{}, {3});
- const auto on_const = op::Constant::create(element::i16, Shape{}, {on_value});
- const auto off_const = op::Constant::create(element::i16, Shape{}, {off_value});
+ const auto on_const = op::Constant::create(element::i32, Shape{}, {on_value});
+ const auto off_const = op::Constant::create(element::i32, Shape{}, {off_value});
int64_t axis = -1;
auto one_hot_v1 =
ASSERT_TRUE(res);
ASSERT_EQ((Shape{4, 3}), res->get_output_shape(0));
- ASSERT_EQ(vector<int16_t>({on_value,
+ ASSERT_EQ(vector<int32_t>({on_value,
off_value,
off_value,
off_value,
off_value,
on_value,
off_value}),
- res->get_vector<int16_t>());
+ res->get_vector<int32_t>());
}
TEST(constant_folding, constant_v1_one_hot_negative_axes_2)
name: "repeats"
type {
tensor_type {
- elem_type: 5
+ elem_type: 7
shape {
dim {
dim_value: 2
auto test_case = test::TestCase<TestEngine, TestCaseType::DYNAMIC>(function);
test_case.add_input<std::int16_t>({0, 1, 2, 3, 4, 5}); // input
- test_case.add_input<std::int16_t>({2, 1}); // repeats
+ test_case.add_input<std::int64_t>({2, 1}); // repeats
test_case.add_expected_output<std::int16_t>(Shape{4, 3}, {0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5});
test_case.run();
}
INTERPRETER.onnx_model_gatherND_int32
INTERPRETER.onnx_model_gatherND_float
-
+
# GRU/RNN/LSTM Sequence: Output values mismatch - seq_lengths not supported
onnx_model_lstm_fwd_mixed_seq_const
onnx_model_lstm_reverse_mixed_seq_const
lstm_cell_bias_peepholes
lstm_cell_bias_peepholes_clip_input_forget
-# unsupported element type f16
+# unsupported element type f16
INTERPRETER.ctc_greedy_decoder_f16
# LogSoftmax's reference implementation doesn't handle scalar input properly
# Dynamic shape support?
onnx_controlflow_loop_2d_trip_count_dynamic
onnx_controlflow_loop_no_variadic_inputs_and_outputs
-onnx_controlflow_loop_power
\ No newline at end of file
+onnx_controlflow_loop_power
+
+# The test fails in CI on Ubuntu i386
+# There's an overflow of some kind: 2147483647 is not close to -2147483648 at index 2
+quantize_clamp_int32
projects / platform / upstream / dldt.git / commitdiff