diff --git a/src/core/dev_api/validation_util.hpp b/src/core/dev_api/validation_util.hpp index 2495fd10299..7e0ca7b8d52 100644 --- a/src/core/dev_api/validation_util.hpp +++ b/src/core/dev_api/validation_util.hpp @@ -58,6 +58,11 @@ OPENVINO_API std::shared_ptr get_constant_from_source(const Ou /// \return Tensor with maximum value. Tensor make_tensor_of_max_value(const element::Type_t et); +/// \brief Make scalar tensor which stores minimum value of ov::element::Type. +/// \param et Element type to get its minimum. +/// \return Tensor with minimum value. +Tensor make_tensor_of_min_value(const element::Type_t et); + /// \brief Apply auto padding to padding_above and padding_below inputs /// if all needed informations are known. /// diff --git a/src/core/include/openvino/op/divide.hpp b/src/core/include/openvino/op/divide.hpp index 4d83d0043f4..33e8ff09043 100644 --- a/src/core/include/openvino/op/divide.hpp +++ b/src/core/include/openvino/op/divide.hpp @@ -45,9 +45,7 @@ public: } std::shared_ptr clone_with_new_inputs(const OutputVector& new_args) const override; - OPENVINO_SUPPRESS_DEPRECATED_START - bool evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const override; - OPENVINO_SUPPRESS_DEPRECATED_END + bool evaluate(TensorVector& outputs, const TensorVector& inputs) const override; bool has_evaluate() const override; bool evaluate_lower(TensorVector& outputs) const override; bool evaluate_upper(TensorVector& outputs) const override; diff --git a/src/core/src/op/divide.cpp b/src/core/src/op/divide.cpp index 03fa88dfbc8..c2a9020cb03 100644 --- a/src/core/src/op/divide.cpp +++ b/src/core/src/op/divide.cpp @@ -2,88 +2,72 @@ // SPDX-License-Identifier: Apache-2.0 // -#include "ngraph/op/divide.hpp" - -#include +#include "openvino/op/divide.hpp" #include "bound_evaluate.hpp" +#include "element_visitor.hpp" #include "itt.hpp" -#include "ngraph/op/and.hpp" -#include "ngraph/op/equal.hpp" -#include "ngraph/op/less.hpp" -#include "ngraph/op/not.hpp" -#include "ngraph/op/or.hpp" -#include "ngraph/op/select.hpp" -#include "ngraph/runtime/host_tensor.hpp" -#include "openvino/core/shape_util.hpp" +#include "openvino/op/constant.hpp" +#include "openvino/op/equal.hpp" +#include "openvino/op/less.hpp" +#include "openvino/op/logical_and.hpp" +#include "openvino/op/logical_or.hpp" +#include "openvino/op/parameter.hpp" +#include "openvino/op/select.hpp" #include "openvino/reference/divide.hpp" +#include "utils.hpp" +#include "validation_util.hpp" -using namespace std; -using namespace ngraph; - -OPENVINO_SUPPRESS_DEPRECATED_START +namespace ov { +namespace op { +namespace v1 { namespace divide { namespace { -template -bool evaluate(const HostTensorPtr& arg0, - const HostTensorPtr& arg1, - const HostTensorPtr& out, - const op::AutoBroadcastSpec& broadcast_spec, - bool pythondiv) { - ov::reference::divide(arg0->get_data_ptr(), - arg1->get_data_ptr(), - out->get_data_ptr(), - arg0->get_shape(), - arg1->get_shape(), +using ov::op::v0::Constant; +using ov::op::v0::Parameter; + +struct Evaluate : element::NoAction { + using element::NoAction::visit; + + template > + static result_type visit(const Tensor& in0, + const Tensor& in1, + Tensor& out, + const Shape& shape0, + const Shape& shape1, + const op::AutoBroadcastSpec& broadcast_spec, + const bool pythondiv) { + reference::divide(in0.data(), + in1.data(), + out.data(), + shape0, + shape1, broadcast_spec, pythondiv); - return true; -} - -bool evaluate_divide(const HostTensorPtr& arg0, - const HostTensorPtr& arg1, - const HostTensorPtr& out, - const op::AutoBroadcastSpec& broadcast_spec, - bool pythondiv) { - bool rc = true; - out->set_broadcast(broadcast_spec, arg0, arg1); - switch (arg0->get_element_type()) { - OPENVINO_TYPE_CASE(evaluate_divide, i32, arg0, arg1, out, broadcast_spec, pythondiv); - OPENVINO_TYPE_CASE(evaluate_divide, i64, arg0, arg1, out, broadcast_spec, pythondiv); - OPENVINO_TYPE_CASE(evaluate_divide, u32, arg0, arg1, out, broadcast_spec, pythondiv); - OPENVINO_TYPE_CASE(evaluate_divide, u64, arg0, arg1, out, broadcast_spec, pythondiv); - OPENVINO_TYPE_CASE(evaluate_divide, f16, arg0, arg1, out, broadcast_spec, pythondiv); - OPENVINO_TYPE_CASE(evaluate_divide, f32, arg0, arg1, out, broadcast_spec, pythondiv); - OPENVINO_TYPE_CASE(evaluate_divide, bf16, arg0, arg1, out, broadcast_spec, pythondiv); - default: - rc = false; - break; + return true; } - return rc; -} +}; -ov::Tensor equality_mask(const ov::Tensor& tensor, const shared_ptr& constant) { - auto mask_out = ov::TensorVector{{element::boolean, tensor.get_shape()}}; +Tensor equality_mask(const Tensor& lhs, const Tensor& rhs) { + auto mask_out = TensorVector{{element::boolean, lhs.get_shape()}}; - auto c_tensor = ov::Tensor(constant->get_element_type(), constant->get_shape()); - memcpy(c_tensor.data(), constant->get_data_ptr(), c_tensor.get_byte_size()); - - const auto& param = std::make_shared(tensor.get_element_type(), tensor.get_shape()); - op::v1::Equal(param, constant).evaluate(mask_out, ov::TensorVector{tensor, c_tensor}); + const auto lhs_node = std::make_shared(lhs.get_element_type(), lhs.get_shape()); + const auto rhs_node = std::make_shared(rhs.get_element_type(), rhs.get_shape()); + Equal(lhs_node, rhs_node).evaluate(mask_out, TensorVector{lhs, rhs}); return mask_out.front(); } -ov::Tensor or_tensor(const ov::Tensor& lhs, const ov::Tensor& rhs) { - auto logical_or = op::v1::LogicalOr(std::make_shared(lhs.get_element_type(), lhs.get_shape()), - std::make_shared(rhs.get_element_type(), rhs.get_shape()), - ngraph::op::AutoBroadcastType::NUMPY); +Tensor or_tensor(const Tensor& lhs, const Tensor& rhs) { + auto logical_or = LogicalOr(std::make_shared(lhs.get_element_type(), lhs.get_shape()), + std::make_shared(rhs.get_element_type(), rhs.get_shape()), + AutoBroadcastType::NUMPY); - auto outs = ov::TensorVector{{lhs.get_element_type(), logical_or.get_output_shape(0)}}; - logical_or.evaluate(outs, ov::TensorVector{lhs, rhs}); + auto outs = TensorVector{{lhs.get_element_type(), logical_or.get_output_shape(0)}}; + logical_or.evaluate(outs, TensorVector{lhs, rhs}); return outs.front(); } -bool evaluate_bound(const Node* node, ov::TensorVector& output_values, bool is_upper) { +bool evaluate_bound(const Node* node, TensorVector& output_values, bool is_upper) { // for positive arg2 divide will have limits [low/up , up/low] // for negative arg2 limits for divide will be [up/low, low/up] // for arg2 range with both positive and negative values, divide can give any result [-inf, inf] @@ -96,109 +80,102 @@ bool evaluate_bound(const Node* node, ov::TensorVector& output_values, bool is_u OPENVINO_ASSERT(PartialShape::broadcast_merge_into(input_shape, input2.get_partial_shape(), node->get_autob()), "Argument shapes in divide operation are inconsistent."); - auto input1_low = ov::evaluate_lower_bound(input1); + const auto input1_low = evaluate_lower_bound(input1); if (!input1_low) return false; - auto input1_up = ov::evaluate_upper_bound(input1); + const auto input1_up = evaluate_upper_bound(input1); if (!input1_up) return false; - auto input2_low = ov::evaluate_lower_bound(input2); + const auto input2_low = evaluate_lower_bound(input2); if (!input2_low) return false; - auto input2_up = ov::evaluate_upper_bound(input2); + const auto input2_up = evaluate_upper_bound(input2); if (!input2_up) return false; - auto zeros_const = op::Constant::create(input2.get_element_type(), {}, {0}); - const auto zero_t = ov::Tensor(input2.get_element_type(), Shape{}); + const auto zeros_const = Constant::create(input2.get_element_type(), {}, {0}); + const auto zero_t = Tensor(input2.get_element_type(), Shape{}); memcpy(zero_t.data(), zeros_const->get_data_ptr(), zero_t.get_byte_size()); - OPENVINO_SUPPRESS_DEPRECATED_START - auto max_constant = get_constant_max_of_type(input2.get_element_type()); - auto dynamic_mask = or_tensor(equality_mask(input1_up, max_constant), equality_mask(input2_up, max_constant)); - OPENVINO_SUPPRESS_DEPRECATED_END + const auto max_value = ov::util::make_tensor_of_max_value(input2.get_element_type()); + const auto dynamic_mask = or_tensor(equality_mask(input1_up, max_value), equality_mask(input2_up, max_value)); // mask to find out positive values for arg2 - auto less_up_outputs = ov::TensorVector{{element::boolean, input2.get_shape()}}; + auto less_up_outputs = TensorVector{{element::boolean, input2.get_shape()}}; auto& input2_positive_up_mask = less_up_outputs.front(); - bool status = op::v1::Less().evaluate(less_up_outputs, ov::TensorVector{zero_t, input2_up}); + bool status = Less().evaluate(less_up_outputs, TensorVector{zero_t, input2_up}); if (!status) return status; // mask to find out negative values for arg2 - auto less_low_outputs = ov::TensorVector{{element::boolean, input2.get_shape()}}; + auto less_low_outputs = TensorVector{{element::boolean, input2.get_shape()}}; auto& input2_negative_low_mask = less_low_outputs.front(); - status = op::v1::Less().evaluate(less_low_outputs, {input2_low, zero_t}); + status = Less().evaluate(less_low_outputs, {input2_low, zero_t}); if (!status) return status; // mask to find out ranges around 0 for arg2 - auto logical_and_up_outputs = ov::TensorVector{{element::boolean, input2.get_shape()}}; + auto logical_and_up_outputs = TensorVector{{element::boolean, input2.get_shape()}}; auto& input2_low_negative_up_positive_mask = logical_and_up_outputs.front(); - status = op::v1::LogicalAnd().evaluate(logical_and_up_outputs, {input2_negative_low_mask, input2_positive_up_mask}); + status = LogicalAnd().evaluate(logical_and_up_outputs, {input2_negative_low_mask, input2_positive_up_mask}); if (!status) return status; - auto value1_outs = ov::TensorVector{{input1.get_element_type(), input_shape.get_shape()}}; + auto value1_outs = TensorVector{{input1.get_element_type(), input_shape.get_shape()}}; auto& value1 = value1_outs.front(); - auto value2_outs = ov::TensorVector{{input2.get_element_type(), input2.get_shape()}}; + auto value2_outs = TensorVector{{input2.get_element_type(), input2.get_shape()}}; auto& value2 = value2_outs.front(); if (!is_upper) { - status = op::v1::Select().evaluate(value1_outs, {input2_positive_up_mask, input1_low, input1_up}); + status = Select().evaluate(value1_outs, {input2_positive_up_mask, input1_low, input1_up}); if (!status) return status; - status = op::v1::Select().evaluate(value2_outs, {input2_positive_up_mask, input2_up, input2_low}); + status = Select().evaluate(value2_outs, {input2_positive_up_mask, input2_up, input2_low}); if (!status) return status; - status = node->evaluate(output_values, ov::TensorVector{value1, value2}); + status = node->evaluate(output_values, TensorVector{value1, value2}); if (!status) return status; // replace values where zeros inside range of second arg to maximum values - OPENVINO_SUPPRESS_DEPRECATED_START - auto output_minimum_value = get_constant_min_of_type(output_values[0].get_element_type()); - OPENVINO_SUPPRESS_DEPRECATED_END - if (output_minimum_value == nullptr) + const auto output_min_value = ov::util::make_tensor_of_min_value(output_values[0].get_element_type()); + if (!output_min_value) return false; - auto out_min_v = ov::Tensor(output_minimum_value->get_element_type(), output_minimum_value->get_shape()); - memcpy(out_min_v.data(), output_minimum_value->get_data_ptr(), out_min_v.get_byte_size()); - - status = op::v1::Select().evaluate(output_values, - {input2_low_negative_up_positive_mask, out_min_v, output_values[0]}); + status = Select().evaluate(output_values, + {input2_low_negative_up_positive_mask, output_min_value, output_values[0]}); if (!status) return status; - status = op::v1::Select().evaluate(output_values, {dynamic_mask, zero_t, output_values[0]}); + status = Select().evaluate(output_values, {dynamic_mask, zero_t, output_values[0]}); if (!status) return status; } else { - status = op::v1::Select().evaluate(value1_outs, {input2_positive_up_mask, input1_up, input1_low}); + status = Select().evaluate(value1_outs, {input2_positive_up_mask, input1_up, input1_low}); if (!status) return status; - status = op::v1::Select().evaluate(value2_outs, {input2_positive_up_mask, input2_low, input2_up}); + status = Select().evaluate(value2_outs, {input2_positive_up_mask, input2_low, input2_up}); if (!status) return status; // create mask where zeros in the second argument are placed - auto eq_zero_mask = ov::TensorVector{{element::boolean, input2.get_shape()}}; + auto eq_zero_mask = TensorVector{{element::boolean, input2.get_shape()}}; auto& input2_zeros_mask = eq_zero_mask.front(); - bool status = op::v1::Equal().evaluate(eq_zero_mask, {value2, zero_t}); + bool status = Equal().evaluate(eq_zero_mask, {value2, zero_t}); if (!status) return status; // replace zeros by 1 values to get result of divide for other values of arguments - auto ones = op::Constant::create(input2.get_element_type(), input2.get_shape(), {1}); - auto ones_t = ov::Tensor(ones->get_element_type(), ones->get_shape()); + const auto ones = Constant::create(input2.get_element_type(), input2.get_shape(), {1}); + const auto ones_t = Tensor(ones->get_element_type(), ones->get_shape()); memcpy(ones_t.data(), ones->get_data_ptr(), ones_t.get_byte_size()); - status = op::v1::Select().evaluate(value2_outs, {input2_zeros_mask, ones_t, value2}); + status = Select().evaluate(value2_outs, {input2_zeros_mask, ones_t, value2}); if (!status) return status; @@ -207,27 +184,22 @@ bool evaluate_bound(const Node* node, ov::TensorVector& output_values, bool is_u return status; // replace values where zeros were found in the second argument to maximum values - OPENVINO_SUPPRESS_DEPRECATED_START - auto output_maximum_value = get_constant_max_of_type(output_values[0].get_element_type()); - OPENVINO_SUPPRESS_DEPRECATED_END - if (output_maximum_value == nullptr) + const auto out_max_value = ov::util::make_tensor_of_max_value(output_values[0].get_element_type()); + if (!out_max_value) return false; - auto out_max_v = ov::Tensor(output_maximum_value->get_element_type(), output_maximum_value->get_shape()); - memcpy(out_max_v.data(), output_maximum_value->get_data_ptr(), out_max_v.get_byte_size()); - - status = op::v1::Select().evaluate(output_values, {input2_zeros_mask, out_max_v, output_values[0]}); + status = Select().evaluate(output_values, {input2_zeros_mask, out_max_value, output_values[0]}); if (!status) return status; // replace values where zeros inside [low, ip] values range of second arg to maximum values - status = op::v1::Select().evaluate(output_values, - {input2_low_negative_up_positive_mask, out_max_v, output_values[0]}); + status = + Select().evaluate(output_values, {input2_low_negative_up_positive_mask, out_max_value, output_values[0]}); if (!status) return status; // in case input elements were dynamic we replace them with zero - status = op::v1::Select().evaluate(output_values, {dynamic_mask, out_max_v, output_values[0]}); + status = Select().evaluate(output_values, {dynamic_mask, out_max_value, output_values[0]}); if (!status) return status; } @@ -236,61 +208,74 @@ bool evaluate_bound(const Node* node, ov::TensorVector& output_values, bool is_u } // namespace } // namespace divide -// ------------------------------ v1 ------------------------------------------- - -op::v1::Divide::Divide(const Output& arg0, const Output& arg1, const AutoBroadcastSpec& auto_broadcast) +Divide::Divide(const Output& arg0, const Output& arg1, const AutoBroadcastSpec& auto_broadcast) : BinaryElementwiseArithmetic(arg0, arg1, auto_broadcast) { constructor_validate_and_infer_types(); } -op::v1::Divide::Divide(const Output& arg0, - const Output& arg1, - bool pythondiv, - const AutoBroadcastSpec& auto_broadcast) +Divide::Divide(const Output& arg0, + const Output& arg1, + bool pythondiv, + const AutoBroadcastSpec& auto_broadcast) : BinaryElementwiseArithmetic(arg0, arg1, auto_broadcast), m_pythondiv(pythondiv) { constructor_validate_and_infer_types(); } -bool op::v1::Divide::visit_attributes(AttributeVisitor& visitor) { +bool Divide::visit_attributes(AttributeVisitor& visitor) { OV_OP_SCOPE(v1_Divide_visit_attributes); BinaryElementwiseArithmetic::visit_attributes(visitor); visitor.on_attribute("m_pythondiv", m_pythondiv); return true; } -shared_ptr op::v1::Divide::clone_with_new_inputs(const OutputVector& new_args) const { +std::shared_ptr Divide::clone_with_new_inputs(const OutputVector& new_args) const { OV_OP_SCOPE(v1_Divide_clone_with_new_inputs); check_new_args_count(this, new_args); - return make_shared(new_args.at(0), new_args.at(1), this->is_pythondiv(), this->get_autob()); + return std::make_shared(new_args.at(0), new_args.at(1), this->is_pythondiv(), this->get_autob()); } -bool op::v1::Divide::evaluate(const HostTensorVector& outputs, const HostTensorVector& inputs) const { +bool Divide::evaluate(TensorVector& outputs, const TensorVector& inputs) const { OV_OP_SCOPE(v1_Divide_evaluate); - return divide::evaluate_divide(inputs[0], inputs[1], outputs[0], get_autob(), is_pythondiv()); + + OPENVINO_ASSERT(outputs.size() == 1); + + outputs[0].set_shape(infer_broadcast_shape(this, inputs)); + using namespace ov::element; + return IfTypeOf::apply(inputs[0].get_element_type(), + inputs[0], + inputs[1], + outputs[0], + inputs[0].get_shape(), + inputs[1].get_shape(), + get_autob(), + is_pythondiv()); + return true; } -bool op::v1::Divide::has_evaluate() const { +bool Divide::has_evaluate() const { OV_OP_SCOPE(v1_Divide_has_evaluate); switch (get_input_element_type(0)) { - case ngraph::element::i32: - case ngraph::element::i64: - case ngraph::element::u32: - case ngraph::element::u64: - case ngraph::element::f16: - case ngraph::element::bf16: - case ngraph::element::f32: + case element::i32: + case element::i64: + case element::u32: + case element::u64: + case element::f16: + case element::bf16: + case element::f32: return true; default: - break; + return false; } - return false; } -bool ov::op::v1::Divide::evaluate_lower(TensorVector& outputs) const { +bool Divide::evaluate_lower(TensorVector& outputs) const { return divide::evaluate_bound(this, outputs, false); } -bool ov::op::v1::Divide::evaluate_upper(TensorVector& outputs) const { +bool Divide::evaluate_upper(TensorVector& outputs) const { return divide::evaluate_bound(this, outputs, true); } +} // namespace v1 +} // namespace op +} // namespace ov diff --git a/src/core/src/validation_util.cpp b/src/core/src/validation_util.cpp index 7662229f2fa..13db184c04b 100644 --- a/src/core/src/validation_util.cpp +++ b/src/core/src/validation_util.cpp @@ -916,32 +916,8 @@ std::shared_ptr get_constant_max_of_type(element::Type_t t) { } std::shared_ptr get_constant_min_of_type(element::Type_t t) { -#define OPENVINO_TYPE_TO_MIN_CONST(t) \ - case t: \ - return ov::op::v0::Constant::create( \ - t, \ - {}, \ - {std::numeric_limits::value_type>::min()}); \ - break - - switch (t) { - OPENVINO_TYPE_TO_MIN_CONST(element::boolean); - OPENVINO_TYPE_TO_MIN_CONST(element::bf16); - OPENVINO_TYPE_TO_MIN_CONST(element::f16); - OPENVINO_TYPE_TO_MIN_CONST(element::f32); - OPENVINO_TYPE_TO_MIN_CONST(element::f64); - OPENVINO_TYPE_TO_MIN_CONST(element::i8); - OPENVINO_TYPE_TO_MIN_CONST(element::i16); - OPENVINO_TYPE_TO_MIN_CONST(element::i32); - OPENVINO_TYPE_TO_MIN_CONST(element::i64); - OPENVINO_TYPE_TO_MIN_CONST(element::u1); - OPENVINO_TYPE_TO_MIN_CONST(element::u8); - OPENVINO_TYPE_TO_MIN_CONST(element::u16); - OPENVINO_TYPE_TO_MIN_CONST(element::u32); - OPENVINO_TYPE_TO_MIN_CONST(element::u64); - default: - return nullptr; - } + auto tensor = ov::util::make_tensor_of_min_value(t); + return tensor ? std::make_shared(tensor) : nullptr; } std::shared_ptr get_constant_lowest_of_type(element::Type_t t) { @@ -1407,6 +1383,48 @@ Tensor make_tensor_of_max_value(const element::Type_t et) { } } +template +Tensor make_tensor_of_min_value(const element::Type_t et) { + Tensor t{et, Shape{}}; + *t.data() = std::numeric_limits::min(); + return t; +} + +Tensor make_tensor_of_min_value(const element::Type_t et) { + switch (et) { + case element::boolean: + return make_tensor_of_min_value>(et); + case element::bf16: + return make_tensor_of_min_value>(et); + case element::f16: + return make_tensor_of_min_value>(et); + case element::f32: + return make_tensor_of_min_value>(et); + case element::f64: + return make_tensor_of_min_value>(et); + case element::i8: + return make_tensor_of_min_value>(et); + case element::i16: + return make_tensor_of_min_value>(et); + case element::i32: + return make_tensor_of_min_value>(et); + case element::i64: + return make_tensor_of_min_value>(et); + case element::u1: + return make_tensor_of_min_value>(et); + case element::u8: + return make_tensor_of_min_value>(et); + case element::u16: + return make_tensor_of_min_value>(et); + case element::u32: + return make_tensor_of_min_value>(et); + case element::u64: + return make_tensor_of_min_value>(et); + default: + return {}; + } +} + std::vector get_tensors_partial_shapes(const TensorVector& tensors) { std::vector shapes; shapes.reserve(tensors.size());