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

[Ref_Impl] Change namespace from nG to OV (#19363)

Browse Source 
* Use quotes for openvino includes

* Drop runtime from openvino::reference

* Drop runtime::reference

* Replace ngraph::reference with ov::reference - defs

* Replace ngraph::reference with ov::reference - uses

* Drop redundant nesting

* Fix non arch64 builds

* Move coordinate*pp files under openvino

* Move Coordinate... helpers under ov:: namespace

* Revert not needed changes

* Fix missing namespace scope

* Fix compilation

* Fix code style

* Use ov suppress deprecated macro instead of ngraph

---------

Co-authored-by: Raasz, Pawel <pawel.raasz@intel.com>
This commit is contained in:
Tomasz Jankowski
2023-09-04 06:07:06 +02:00
committed by GitHub
parent 92c6316e8e
commit 51df17912b
398 changed files with 2613 additions and 3048 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/common/offline_transformations/src/pruning/init_const_mask.cpp
View File

@@ -5,10 +5,10 @@
#include <memory>
#include "mask_attribute.hpp"
#include "ngraph/coordinate_transform.hpp"
#include "openvino/op/log.hpp"
#include "openvino/opsets/opset6.hpp"
#include "openvino/pass/pattern/op/wrap_type.hpp"
#include "openvino/reference/utils/coordinate_transform.hpp"
#include "pruning.hpp"
ov::pass::InitConstMask::InitConstMask(const ov::AxisSet& dims,
@@ -43,7 +43,7 @@ ov::pass::InitConstMask::InitConstMask(const ov::AxisSet& dims,
bool skip_dim_value = false;
OPENVINO_SUPPRESS_DEPRECATED_START
ngraph::CoordinateTransform iter(shape, begin, end);
ov::CoordinateTransform iter(shape, begin, end);
for (const Coordinate& coord : iter) {
if (!condition(values.at(iter.index(coord)))) {
skip_dim_value = true;

10
src/common/offline_transformations/src/pruning/propagate_masks.cpp
View File

@@ -7,7 +7,6 @@
#include <memory>
#include "mask_attribute.hpp"
#include "ngraph/coordinate_transform.hpp"
#include "openvino/core/rt_info.hpp"
#include "openvino/core/validation_util.hpp"
#include "openvino/op/gelu.hpp"
@@ -17,6 +16,7 @@
#include "openvino/op/util/pad_base.hpp"
#include "openvino/opsets/opset10.hpp"
#include "openvino/pass/pattern/op/wrap_type.hpp"
#include "openvino/reference/utils/coordinate_transform.hpp"
#include "openvino/util/log.hpp"
#include "pruning.hpp"
@@ -1015,14 +1015,14 @@ struct ChannelsMap {
* on unsquized_shape_dim dimension according to unsquized_shape shape.
*/
OPENVINO_SUPPRESS_DEPRECATED_START
static ngraph::CoordinateTransform get_channel_iter(const ov::Shape unsquized_shape,
const size_t unsquized_shape_dim,
const size_t channel) {
static ov::CoordinateTransform get_channel_iter(const ov::Shape unsquized_shape,
const size_t unsquized_shape_dim,
const size_t channel) {
auto begin = ov::Coordinate(unsquized_shape.size(), 0);
auto end = ov::Coordinate(unsquized_shape);
begin[unsquized_shape_dim] = channel;
end[unsquized_shape_dim] = channel + 1;
ngraph::CoordinateTransform iter(unsquized_shape, begin, end);
ov::CoordinateTransform iter(unsquized_shape, begin, end);
return iter;
}
OPENVINO_SUPPRESS_DEPRECATED_END

55
src/common/snippets/src/pass/fq_decomposition.cpp
View File

@@ -6,13 +6,13 @@
#include <numeric>
#include "ngraph/runtime/reference/autobroadcast_binop.hpp"
#include "openvino/core/rt_info.hpp"
#include "openvino/opsets/opset1.hpp"
#include "openvino/pass/constant_folding.hpp"
#include "openvino/pass/manager.hpp"
#include "openvino/pass/pattern/op/wrap_type.hpp"
#include "openvino/pass/validate.hpp"
#include "openvino/reference/autobroadcast_binop.hpp"
#include "openvino/reference/broadcast.hpp"
#include "snippets/itt.hpp"
#include "snippets/op/convert_saturation.hpp"
@@ -208,9 +208,10 @@ bool ov::snippets::pass::FakeQuantizeDecomposition::getScalesAndShifts(
auto broadcast_type = fq_node->get_auto_broadcast();
// We have two ways for computations of scales and shifts to avoid model compilation time growth
// because common function "ov::runtime::reference::autobroadcast_binop()" is expensive:
// because common function "ov::reference::autobroadcast_binop()" is expensive:
// - A usual case (weights with the same shapes or scalars) - optimal calculations without large broadcasting
// - A rare case ("general broadcasting") - common computations using autobroadcast_binop() call with broadcasting support
// - A rare case ("general broadcasting") - common computations using autobroadcast_binop() call with broadcasting
// support
// Calculations of input scales and shift:
// - isc := (levels-1) / (ih - il)
@@ -235,23 +236,35 @@ bool ov::snippets::pass::FakeQuantizeDecomposition::getScalesAndShifts(
const auto input_size = ov::shape_size(scale_shape);
isc.resize(input_size, 0);
ish.resize(input_size, 0);
ngraph::runtime::reference::autobroadcast_binop(input_high.data(), input_low.data(), isc.data(),
input_high_shape, input_low_shape, broadcast_type,
[levels](float x, float y) -> float { return (levels - 1) / (x - y); });
ngraph::runtime::reference::autobroadcast_binop(input_low.data(), isc.data(), ish.data(),
input_low_shape, scale_shape, broadcast_type,
[](float x, float y) -> float { return -x * y; });
ov::reference::autobroadcast_binop(input_high.data(),
input_low.data(),
isc.data(),
input_high_shape,
input_low_shape,
broadcast_type,
[levels](float x, float y) -> float {
return (levels - 1) / (x - y);
});
ov::reference::autobroadcast_binop(input_low.data(),
isc.data(),
ish.data(),
input_low_shape,
scale_shape,
broadcast_type,
[](float x, float y) -> float {
return -x * y;
});
auto broadcast = [](const std::vector<float>& original_data, std::vector<float>& out_data,
const ov::Shape& original_shape, const ov::Shape& out_shape, size_t size) -> void {
out_data.resize(size, 0);
std::vector<size_t> broadcast_axes(out_shape.size() - original_shape.size());
std::iota(broadcast_axes.begin(), broadcast_axes.end(), 0);
ngraph::runtime::reference::broadcast(reinterpret_cast<const char*>(original_data.data()),
reinterpret_cast<char*>(out_data.data()),
original_shape,
out_shape,
broadcast_axes,
sizeof(float));
ov::reference::broadcast(reinterpret_cast<const char*>(original_data.data()),
reinterpret_cast<char*>(out_data.data()),
original_shape,
out_shape,
broadcast_axes,
sizeof(float));
};
broadcast(input_low, cl, input_low_shape, scale_shape, input_size);
broadcast(input_high, ch, input_high_shape, scale_shape, input_size);
@@ -276,9 +289,15 @@ bool ov::snippets::pass::FakeQuantizeDecomposition::getScalesAndShifts(
PartialShape::broadcast_merge_into(scale_pshape, output_high_constant->get_output_partial_shape(0), broadcast_type);
const auto output_size = ov::shape_size(scale_pshape.get_shape());
osc.resize(output_size, 0);
ngraph::runtime::reference::autobroadcast_binop(output_high.data(), output_low.data(), osc.data(),
output_high_shape, output_low_shape, broadcast_type,
[levels](float x, float y) -> float { return (x - y) / (levels - 1); });
ov::reference::autobroadcast_binop(output_high.data(),
output_low.data(),
osc.data(),
output_high_shape,
output_low_shape,
broadcast_type,
[levels](float x, float y) -> float {
return (x - y) / (levels - 1);
});
osh = output_low;
}

4
src/common/transformations/src/transformations/common_optimizations/compress_float_constants.cpp
View File

@@ -96,7 +96,7 @@ ov::pass::CompressFloatConstantsImpl::CompressFloatConstantsImpl(bool postponed)
if (size == 0)
return false;
auto num_out_of_range =
ngraph::runtime::reference::count_out_of_f16_range(const_node->get_data_ptr<ov::element::f32>(), size);
ov::reference::count_out_of_f16_range(const_node->get_data_ptr<ov::element::f32>(), size);
// if more than 75% of a FP32 constant do not fit into FP16 keep in FP32
const float keep_threshold = 0.75f;
@@ -113,7 +113,7 @@ ov::pass::CompressFloatConstantsImpl::CompressFloatConstantsImpl(bool postponed)
auto* dst_data =
const_cast<ov::float16*>(reinterpret_cast<const ov::float16*>(compressed_const->get_data_ptr()));
OPENVINO_ASSERT(dst_data);
ngraph::runtime::reference::convert_from_f32_to_f16_with_clamp(src_data, dst_data, size);
ov::reference::convert_from_f32_to_f16_with_clamp(src_data, dst_data, size);
new_const = compressed_const;
}
} else if (c_type == ov::element::f64) {

4
src/common/transformations/src/transformations/convert_precision.cpp
View File

@@ -907,7 +907,7 @@ std::shared_ptr<Node> change_constant_precision<ov::element::Type_t::f32, ov::el
if (dst_data == nullptr)
OPENVINO_THROW("Can't get destination data pointer");
ngraph::runtime::reference::convert_from_f32_to_f16_with_clamp(src_data, dst_data, size);
ov::reference::convert_from_f32_to_f16_with_clamp(src_data, dst_data, size);
return new_constant;
}
@@ -927,7 +927,7 @@ std::shared_ptr<Node> change_constant_precision<ov::element::Type_t::f16, ov::el
if (dst_data == nullptr)
OPENVINO_THROW("Can't get destination data pointer");
ngraph::runtime::reference::convert<src_type, dst_type>(src_data, dst_data, size);
ov::reference::convert<src_type, dst_type>(src_data, dst_data, size);
return new_constant;
}

6
src/common/transformations/tests/offline_transformations/pruning_test.cpp
View File

@@ -13,7 +13,6 @@
#include "common_test_utils/ov_test_utils.hpp"
#include "inference_engine.hpp"
#include "mask_attribute.hpp"
#include "ngraph/coordinate_transform.hpp"
#include "openvino/core/model.hpp"
#include "openvino/op/util/attr_types.hpp"
#include "openvino/op/util/pad_base.hpp"
@@ -22,6 +21,7 @@
#include "openvino/pass/manager.hpp"
#include "openvino/pass/serialize.hpp"
#include "openvino/pass/visualize_tree.hpp"
#include "openvino/reference/utils/coordinate_transform.hpp"
#include "openvino/util/env_util.hpp"
#include "transformations/init_node_info.hpp"
@@ -52,7 +52,7 @@ Output<Node> create_constant_with_zeros(const Shape& shape, const Mask& mask) {
coord_end[dim] = dim_value + 1;
OPENVINO_SUPPRESS_DEPRECATED_START
ngraph::CoordinateTransform iter(shape, coord_begin, coord_end);
ov::CoordinateTransform iter(shape, coord_begin, coord_end);
for (const Coordinate& coord : iter) {
values[iter.index(coord)] = 0;
}
@@ -138,7 +138,7 @@ TEST(TransformationTests, InitMasksOutputChannel) {
Shape weights_shape{6, 3, 3, 3};
std::vector<double> values(shape_size(weights_shape), 1);
OPENVINO_SUPPRESS_DEPRECATED_START
ngraph::CoordinateTransform iter(weights_shape, {0, 1, 0, 0}, {6, 2, 3, 3});
ov::CoordinateTransform iter(weights_shape, {0, 1, 0, 0}, {6, 2, 3, 3});
for (const Coordinate& coord : iter) {
values[iter.index(coord)] = 0;
}

6
src/core/reference/include/openvino/reference/abs.hpp
View File

@@ -7,8 +7,7 @@
#include <cstddef>
#include <type_traits>
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T, typename std::enable_if<std::is_unsigned<T>::value, bool>::type = true>
void abs(const T* arg, T* out, size_t count) {
@@ -23,5 +22,4 @@ void abs(const T* arg, T* out, size_t count) {
}
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/adaptive_avg_pool.hpp
View File

@@ -11,8 +11,7 @@
#include "ngraph/axis_vector.hpp"
#include "ngraph/shape.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
namespace adaptive_pool {
inline size_t window_start(size_t idx, size_t arg_shape, size_t out_shape) {
@@ -130,5 +129,4 @@ void adaptive_avg_pool(const T* arg, T* out, const Shape& arg_shape, const Shape
}
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/adaptive_max_pool.hpp
View File

@@ -11,8 +11,7 @@
#include "ngraph/axis_vector.hpp"
#include "ngraph/shape.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T, typename IT>
void adaptive_max_pool_1d(const T* arg, T* out, IT* indices, size_t h_in, size_t h_out) {
@@ -126,5 +125,4 @@ void adaptive_max_pool(const T* arg, T* out, IT* selected_indices, const Shape&
}
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

8
src/core/reference/include/openvino/reference/add.hpp
View File

@@ -6,11 +6,10 @@
#include <cstddef>
#include "ngraph/runtime/reference/autobroadcast_binop.hpp"
#include "ngraph/shape_util.hpp"
#include "openvino/reference/autobroadcast_binop.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T>
void add(const T* arg0, const T* arg1, T* out, size_t count) {
@@ -31,5 +30,4 @@ void add(const T* arg0,
});
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

8
src/core/reference/include/openvino/reference/and.hpp
View File

@@ -7,11 +7,10 @@
#include <cstddef>
#include "ngraph/op/util/attr_types.hpp"
#include "ngraph/runtime/reference/autobroadcast_binop.hpp"
#include "ngraph/shape.hpp"
#include "openvino/reference/autobroadcast_binop.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T>
void logical_and(const T* arg0, const T* arg1, T* out, size_t count) {
@@ -32,5 +31,4 @@ void logical_and(const T* arg0,
});
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/atan2.hpp
View File

@@ -7,8 +7,7 @@
#include <cmath>
#include <cstddef>
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename X, typename Y, typename Z>
void atan2(const X* py, const Y* px, Z* pout, size_t count) {
@@ -17,5 +16,4 @@ void atan2(const X* py, const Y* px, Z* pout, size_t count) {
}
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

11
src/core/reference/include/openvino/reference/autobroadcast_binop.hpp
View File

@@ -8,9 +8,9 @@
#include <numeric>
#include <utility>
#include "ngraph/coordinate_transform.hpp"
#include "ngraph/op/util/attr_types.hpp"
#include "ngraph/shape_util.hpp"
#include "openvino/reference/utils/coordinate_transform.hpp"
namespace ov {
namespace reference {
@@ -44,7 +44,6 @@ inline void numpy_autobroadcast_binop(const T* arg0,
const size_t axis,
const size_t stride,
Functor elementwise_functor) {
using ngraph::CoordinateIterator;
for (CoordinateIterator it(output_shape), ite = CoordinateIterator::end();;) {
for (size_t i = 0; i < stride; ++i)
*out++ = elementwise_functor(arg0[i * A0], arg1[i * A1]);
@@ -264,9 +263,9 @@ void autobroadcast_binop(const T* arg0,
}
NGRAPH_SUPPRESS_DEPRECATED_START
ngraph::CoordinateTransform arg0_transform(arg0_shape);
ngraph::CoordinateTransform arg1_transform(arg1_squeezed_shape);
ngraph::CoordinateTransform output_transform(arg0_shape);
CoordinateTransform arg0_transform(arg0_shape);
CoordinateTransform arg1_transform(arg1_squeezed_shape);
CoordinateTransform output_transform(arg0_shape);
for (const Coordinate& output_coord : output_transform) {
Coordinate arg1_coord = ngraph::reduce(output_coord, arg1_squeezed_axes, false);
@@ -309,8 +308,6 @@ void autobroadcast_select(const U* arg0,
const Shape& arg2_shape,
const op::AutoBroadcastSpec& broadcast_spec,
Functor elementwise_functor) {
using ngraph::CoordinateTransformBasic;
switch (broadcast_spec.m_type) {
case op::AutoBroadcastType::NONE:
for (size_t i = 0; i < shape_size(arg0_shape); i++) {

8
src/core/reference/include/openvino/reference/avg_pool.hpp
View File

@@ -11,11 +11,10 @@
#include <vector>
#include "ngraph/axis_vector.hpp"
#include "ngraph/coordinate_transform.hpp"
#include "ngraph/shape.hpp"
#include "openvino/reference/utils/coordinate_transform.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T>
void avg_pool_backprop(const T* delta,
@@ -231,5 +230,4 @@ void avg_pool(const T* arg,
NGRAPH_SUPPRESS_DEPRECATED_END
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

8
src/core/reference/include/openvino/reference/batch_norm.hpp
View File

@@ -7,11 +7,10 @@
#include <cmath>
#include <vector>
#include "ngraph/coordinate_transform.hpp"
#include "ngraph/shape.hpp"
#include "openvino/reference/utils/coordinate_transform.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T>
static inline T norm(T val, T mean, T var, T eps) {
@@ -46,5 +45,4 @@ void batch_norm_inference(float eps,
NGRAPH_SUPPRESS_DEPRECATED_END
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/binary_convolution.hpp
View File

@@ -7,8 +7,7 @@
#include "ngraph/shape.hpp"
#include "openvino/reference/convolution.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
namespace details {
inline uint8_t extract_bit(uint8_t val, uint8_t bit) {
@@ -143,5 +142,4 @@ void binary_convolution(const T_IN* in,
}
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/broadcast.hpp
View File

@@ -7,8 +7,7 @@
#include "ngraph/axis_set.hpp"
#include "ngraph/shape.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
void broadcast(const char* arg,
char* out,
@@ -17,5 +16,4 @@ void broadcast(const char* arg,
const AxisSet& broadcast_axes,
size_t elem_size);
}
} // namespace runtime
} // namespace ngraph
} // namespace ov

8
src/core/reference/include/openvino/reference/bucketize.hpp
View File

@@ -8,8 +8,7 @@
#include "ngraph/shape.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T, typename B, typename P>
void bucketize(const T* data,
@@ -40,7 +39,4 @@ void bucketize(const T* data,
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/ceiling.hpp
View File

@@ -7,8 +7,7 @@
#include <cmath>
#include <cstddef>
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T>
void ceiling(const T* arg, T* out, size_t count) {
@@ -17,5 +16,4 @@ void ceiling(const T* arg, T* out, size_t count) {
}
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/clamp.hpp
View File

@@ -7,8 +7,7 @@
#include <cmath>
#include <cstddef>
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T>
void clamp(const T* arg, T* out, T min, T max, size_t count) {
@@ -23,5 +22,4 @@ void clamp(const T* arg, T* out, T min, T max, size_t count) {
}
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/concat.hpp
View File

@@ -8,8 +8,7 @@
#include "ngraph/shape.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
void concat(const std::vector<const char*>& args,
char* out,
@@ -18,5 +17,4 @@ void concat(const std::vector<const char*>& args,
int64_t concatenation_axis,
size_t elem_size);
}
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/constant.hpp
View File

@@ -6,8 +6,7 @@
#include <cstddef>
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T>
void constant(const T* arg0, T* out, size_t count) {
@@ -16,5 +15,4 @@ void constant(const T* arg0, T* out, size_t count) {
}
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/convert.hpp
View File

@@ -9,8 +9,7 @@
#include "ngraph/type/element_type.hpp"
#include "ngraph/type/float16.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
namespace detail {
inline void set_u1(uint8_t* buf, size_t idx, uint8_t val) {
@@ -130,5 +129,4 @@ typename std::enable_if<std::is_same<TO, char>::value>::type convert(const TI* a
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/convert_color_nv12.hpp
View File

@@ -10,8 +10,7 @@
#include "openvino/op/util/convert_color_i420_base.hpp"
#include "openvino/op/util/convert_color_nv12_base.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T>
@@ -206,5 +205,4 @@ inline bool color_convert_i420(const std::shared_ptr<Node>& op,
OPENVINO_SUPPRESS_DEPRECATED_END
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/convolution.hpp
View File

@@ -8,8 +8,7 @@
#include "ngraph/util.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
namespace {
@@ -407,8 +406,7 @@ void convolution(const T* in,
}
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov
// can't be removed currently due to arm-plugin dependency
#include "openvino/reference/convolution_backprop_data.hpp"

6
src/core/reference/include/openvino/reference/convolution_backprop_data.hpp
View File

@@ -14,8 +14,7 @@
#include "openvino/reference/convolution.hpp"
#include "openvino/reference/reverse.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
namespace {
constexpr size_t filter_input_ch_axis = 0;
@@ -395,5 +394,4 @@ void convolution_backprop_in(const T* delta_in,
output_padding);
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/copy.hpp
View File

@@ -6,8 +6,7 @@
#include <cstddef>
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T>
void copy(const T* arg, T* out, size_t count) {
@@ -16,5 +15,4 @@ void copy(const T* arg, T* out, size_t count) {
}
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

13
src/core/reference/include/openvino/reference/ctc_greedy_decoder.hpp
View File

@@ -8,9 +8,9 @@
#include <limits>
#include <vector>
#include "ngraph/coordinate_transform.hpp"
namespace ngraph {
namespace runtime {
#include "openvino/reference/utils/coordinate_transform.hpp"
namespace ov {
namespace reference {
template <typename T>
void ctc_greedy_decoder(const T* data,
@@ -20,7 +20,7 @@ void ctc_greedy_decoder(const T* data,
const Shape& sequence_masks_shape,
const Shape& out_shape,
const bool ctc_merge_repeated) {
NGRAPH_SUPPRESS_DEPRECATED_START
OPENVINO_SUPPRESS_DEPRECATED_START
const auto max_seq_len = data_shape[0];
const auto batch_size = data_shape[1];
const auto class_count = data_shape[2];
@@ -59,8 +59,7 @@ void ctc_greedy_decoder(const T* data,
}
}
std::copy(tmp_out.begin(), tmp_out.end(), out);
NGRAPH_SUPPRESS_DEPRECATED_END
OPENVINO_SUPPRESS_DEPRECATED_END
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

8
src/core/reference/include/openvino/reference/ctc_greedy_decoder_seq_len.hpp
View File

@@ -8,9 +8,8 @@
#include <limits>
#include <vector>
#include "ngraph/coordinate_transform.hpp"
namespace ngraph {
namespace runtime {
#include "openvino/reference/utils/coordinate_transform.hpp"
namespace ov {
namespace reference {
template <typename TF, typename TI, typename TCI, typename TSL>
void ctc_greedy_decoder_seq_len(const TF* data,
@@ -44,5 +43,4 @@ void ctc_greedy_decoder_seq_len(const TF* data,
}
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/ctc_loss.hpp
View File

@@ -8,8 +8,7 @@
#include "ngraph/shape_util.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T, typename U>
void CTCLoss(const T* logits,
@@ -162,5 +161,4 @@ void CTCLoss(const T* logits,
} // for (size_t b = 0; b < batchNum; b++)
} // CTCLoss
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/cum_sum.hpp
View File

@@ -6,8 +6,7 @@
#include <cmath>
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T, typename P>
@@ -42,5 +41,4 @@ void cumsum(const T* arg,
}
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/deformable_convolution.hpp
View File

@@ -6,8 +6,7 @@
#include "openvino/reference/convolution.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
namespace def_conv_impl {
inline void validate_deformable_convolution_params(const Shape& in_shape,
@@ -316,5 +315,4 @@ void deformable_convolution(const T* in,
bilinear_interpolation_pad);
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/deformable_psroi_pooling.hpp
View File

@@ -16,8 +16,7 @@
#include "clamp.hpp"
#include "ngraph/shape.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T>
void deformable_psroi_pooling(const T* data_input,
@@ -172,5 +171,4 @@ void deformable_psroi_pooling(const T* data_input,
}
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

8
src/core/reference/include/openvino/reference/depth_to_space.hpp
View File

@@ -7,16 +7,14 @@
#include "ngraph/op/depth_to_space.hpp"
#include "ngraph/shape.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
void depth_to_space(const char* const in,
const Shape& in_shape,
char* const out,
const Shape& out_shape,
const size_t block_size,
const op::DepthToSpace::DepthToSpaceMode mode,
const op::v0::DepthToSpace::DepthToSpaceMode mode,
const size_t elem_size);
}
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/detection_output.hpp
View File

@@ -13,8 +13,7 @@
#include "ngraph/op/util/detection_output_base.hpp"
#include "ngraph/shape.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
enum { idxLocation, idxConfidence, idxPriors, idxArmConfidence, idxArmLocation, numInputs };
@@ -588,5 +587,4 @@ public:
}
};
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

8
src/core/reference/include/openvino/reference/divide.hpp
View File

@@ -9,13 +9,12 @@
#include <type_traits>
#include "ngraph/op/util/attr_types.hpp"
#include "ngraph/runtime/reference/autobroadcast_binop.hpp"
#include "ngraph/shape.hpp"
#include "ngraph/type/bfloat16.hpp"
#include "ngraph/type/float16.hpp"
#include "openvino/reference/autobroadcast_binop.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
// NOTE: Execution throws `std::domain_error` if either a non-integral value or an
// out-of-bounds value is detected in the input tensor.
@@ -110,5 +109,4 @@ divide(const T* arg0,
});
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/einsum.hpp
View File

@@ -9,10 +9,8 @@
#include "ngraph/shape.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
void einsum(const HostTensorVector& outputs, const HostTensorVector& inputs, const std::string& equation);
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/elu.hpp
View File

@@ -7,8 +7,7 @@
#include <cmath>
#include <cstddef>
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T>
void elu(const T* arg, T* out, size_t count, double alpha) {
@@ -17,5 +16,4 @@ void elu(const T* arg, T* out, size_t count, double alpha) {
}
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/embedding_bag_offsets_sum.hpp
View File

@@ -6,8 +6,7 @@
#include "ngraph/shape_util.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T, typename U>
void embeddingBagOffsetsSum(const T* emb_table,
@@ -93,5 +92,4 @@ void embeddingBagOffsetsSum(const T* emb_table,
} // embeddingBagOffsetsSum
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/embedding_bag_packed_sum.hpp
View File

@@ -6,8 +6,7 @@
#include "ngraph/shape_util.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T, typename U>
void embeddingBagPackedSum(const T* emb_table,
@@ -47,5 +46,4 @@ void embeddingBagPackedSum(const T* emb_table,
} // embeddingBagPackedSum
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/embedding_segments_sum.hpp
View File

@@ -6,8 +6,7 @@
#include "ngraph/shape_util.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T, typename U>
void embeddingSegmentsSum(const T* embTable,
@@ -72,5 +71,4 @@ void embeddingSegmentsSum(const T* embTable,
} // embeddingSegmentsSum
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

8
src/core/reference/include/openvino/reference/equal.hpp
View File

@@ -12,11 +12,10 @@
#include <cstddef>
#include "ngraph/op/util/attr_types.hpp"
#include "ngraph/runtime/reference/autobroadcast_binop.hpp"
#include "ngraph/shape.hpp"
#include "openvino/reference/autobroadcast_binop.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T>
void equal(const T* arg0,
@@ -41,8 +40,7 @@ void equal(const T* arg0,
});
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov
#if defined(__GNUC__)
# pragma GCC diagnostic pop

6
src/core/reference/include/openvino/reference/erf.hpp
View File

@@ -11,8 +11,7 @@
#include "ngraph/type/bfloat16.hpp"
#include "ngraph/type/float16.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T, typename std::enable_if<!std::is_integral<T>::value, bool>::type = true>
void erf(const T* arg, T* out, size_t count) {
@@ -28,5 +27,4 @@ void erf(const T* arg, T* out, size_t count) {
}
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/exp.hpp
View File

@@ -7,8 +7,7 @@
#include <cmath>
#include <cstddef>
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T>
void exp(const T* arg, T* out, size_t count) {
@@ -17,5 +16,4 @@ void exp(const T* arg, T* out, size_t count) {
}
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/experimental_detectron_detection_output.hpp
View File

@@ -27,8 +27,7 @@
#include "ngraph/ops.hpp"
#include "ngraph/shape_util.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
void experimental_detectron_detection_output(const float* input_rois,
const float* input_deltas,
@@ -50,5 +49,4 @@ void experimental_detectron_detection_output_postprocessing(void* pboxes,
const Shape& output_classes_shape,
const Shape& output_scores_shape);
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/experimental_detectron_prior_grid_generator.hpp
View File

@@ -26,8 +26,7 @@
#include "ngraph/ops.hpp"
#include "ngraph/shape_util.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T>
void experimental_detectron_prior_grid_generator(const T* priors,
@@ -58,5 +57,4 @@ void experimental_detectron_prior_grid_generator(const T* priors,
}
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/experimental_detectron_proposal_single_image.hpp
View File

@@ -15,8 +15,7 @@
#include "ngraph/ops.hpp"
#include "ngraph/shape_util.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
void experimental_detectron_proposals_single_image(
const float* im_info,
@@ -39,5 +38,4 @@ void experimental_detectron_proposals_single_image_postprocessing(void* prois,
const Shape& output_rois_shape,
const Shape& output_scores_shape);
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/experimental_detectron_roi_feature_extractor.hpp
View File

@@ -14,8 +14,7 @@
#include "ngraph/ops.hpp"
#include "ngraph/shape_util.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
void experimental_detectron_roi_feature_extractor(
const std::vector<std::vector<float>>& inputs,
@@ -32,5 +31,4 @@ void experimental_detectron_roi_feature_extractor_postprocessing(void* prois_fea
const Shape& output_roi_features_shape,
const Shape& output_rois_shape);
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/experimental_detectron_topk_rois.hpp
View File

@@ -15,8 +15,7 @@
#include "ngraph/ops.hpp"
#include "ngraph/shape_util.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T>
void experimental_detectron_topk_rois(const T* input_rois,
@@ -43,5 +42,4 @@ void experimental_detectron_topk_rois(const T* input_rois,
}
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

8
src/core/reference/include/openvino/reference/extract_image_patches.hpp
View File

@@ -6,11 +6,10 @@
#include "ngraph/shape_util.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T>
void extract_image_patches(const std::shared_ptr<op::ExtractImagePatches> extImgPatches,
void extract_image_patches(const std::shared_ptr<op::v3::ExtractImagePatches> extImgPatches,
const T* input,
T* out,
const Shape& inShape,
@@ -115,5 +114,4 @@ void extract_image_patches(const std::shared_ptr<op::ExtractImagePatches> extImg
} // extractImagePatches
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/eye.hpp
View File

@@ -9,8 +9,7 @@
#include "ngraph/shape.hpp"
#include "utils/span.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T>
void eye(T* data, const Shape& out_shape, const int64_t diagonal_index) {
@@ -37,5 +36,4 @@ void eye(T* data, const Shape& out_shape, const int64_t diagonal_index) {
}
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

18
src/core/reference/include/openvino/reference/fake_quantize.hpp
View File

@@ -12,13 +12,12 @@
#include <vector>
#include "ngraph/check.hpp"
#include "ngraph/coordinate_transform.hpp"
#include "ngraph/op/util/attr_types.hpp"
#include "ngraph/shape.hpp"
#include "ngraph/shape_util.hpp"
#include "openvino/reference/utils/coordinate_transform.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
namespace fake_quantize_details {
template <typename T>
@@ -158,11 +157,11 @@ void fake_quantize(const T* const arg,
for (const Coordinate& output_coord : output_transform) {
OPENVINO_SUPPRESS_DEPRECATED_START
const Coordinate arg0_coord = reduce(output_coord, arg0_squeezed_axes, false);
const Coordinate arg1_coord = reduce(output_coord, arg1_squeezed_axes, false);
const Coordinate arg2_coord = reduce(output_coord, arg2_squeezed_axes, false);
const Coordinate arg3_coord = reduce(output_coord, arg3_squeezed_axes, false);
const Coordinate arg4_coord = reduce(output_coord, arg4_squeezed_axes, false);
const Coordinate arg0_coord = ngraph::reduce(output_coord, arg0_squeezed_axes, false);
const Coordinate arg1_coord = ngraph::reduce(output_coord, arg1_squeezed_axes, false);
const Coordinate arg2_coord = ngraph::reduce(output_coord, arg2_squeezed_axes, false);
const Coordinate arg3_coord = ngraph::reduce(output_coord, arg3_squeezed_axes, false);
const Coordinate arg4_coord = ngraph::reduce(output_coord, arg4_squeezed_axes, false);
OPENVINO_SUPPRESS_DEPRECATED_END
const size_t arg0_idx =
@@ -187,5 +186,4 @@ void fake_quantize(const T* const arg,
}
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/fft.hpp
View File

@@ -31,8 +31,7 @@
#include "ngraph/ops.hpp"
#include "ngraph/shape_util.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
enum class FFTKind { Forward, Inverse };
@@ -52,5 +51,4 @@ std::vector<int64_t> canonicalize_axes(const int64_t* axes_data,
const Shape& axes_data_shape,
int64_t complex_data_rank);
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/floor.hpp
View File

@@ -7,8 +7,7 @@
#include <cmath>
#include <cstddef>
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T>
void floor(const T* arg, T* out, size_t count) {
@@ -17,5 +16,4 @@ void floor(const T* arg, T* out, size_t count) {
}
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

8
src/core/reference/include/openvino/reference/floor_mod.hpp
View File

@@ -7,11 +7,10 @@
#include <cmath>
#include <cstddef>
#include "ngraph/runtime/reference/autobroadcast_binop.hpp"
#include "ngraph/shape_util.hpp"
#include "openvino/reference/autobroadcast_binop.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T>
void floor_mod(const T* arg0,
@@ -28,5 +27,4 @@ void floor_mod(const T* arg0,
});
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

10
src/core/reference/include/openvino/reference/function.hpp
View File

@@ -8,12 +8,10 @@
#include <cstddef>
#include <vector>
#include "ngraph/function.hpp"
#include "openvino/core/model.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
void function(const std::shared_ptr<Function>& function, const HostTensorVector& inputs, HostTensorVector& outputs);
void function(const std::shared_ptr<Model>& function, const HostTensorVector& inputs, HostTensorVector& outputs);
}
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/gather.hpp
View File

@@ -9,8 +9,7 @@
#include "ngraph/shape.hpp"
#include "utils/span.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T, typename U>
void gather(const T* const data,
@@ -57,5 +56,4 @@ void gather(const T* const data,
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

9
src/core/reference/include/openvino/reference/gather_elements.hpp
View File

@@ -4,11 +4,9 @@
#pragma once
#include "ngraph/coordinate_index.hpp"
#include "ngraph/coordinate_transform.hpp"
#include "openvino/reference/utils/coordinate_transform.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T, typename U>
void gather_elements(const T* data,
@@ -109,5 +107,4 @@ void gather_elements(const T* data,
}
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

8
src/core/reference/include/openvino/reference/gather_nd.hpp
View File

@@ -8,11 +8,10 @@
#include <cassert>
#include <numeric>
#include "ngraph/coordinate_transform.hpp"
#include "openvino/reference/utils/coordinate_transform.hpp"
#include "utils/span.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
namespace details {
template <typename Iterator>
@@ -106,5 +105,4 @@ void gather_nd(const T* const params,
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/gather_tree.hpp
View File

@@ -7,8 +7,7 @@
#include "ngraph/shape.hpp"
#include "ngraph/type/element_type.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
void gather_tree(const char* step_ids,
const char* parent_ids,
@@ -21,5 +20,4 @@ void gather_tree(const char* step_ids,
const Shape& end_token_shape,
const element::Type& type);
}
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/gelu.hpp
View File

@@ -8,8 +8,7 @@
#include <cstddef>
#include <ngraph/op/gelu.hpp>
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T>
void gelu(const T* arg, T* out, op::GeluApproximationMode mode, size_t count) {
@@ -27,5 +26,4 @@ void gelu(const T* arg, T* out, op::GeluApproximationMode mode, size_t count) {
}
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/generate_proposal.hpp
View File

@@ -15,8 +15,7 @@
#include "ngraph/ops.hpp"
#include "ngraph/shape_util.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
void generate_proposals(const std::vector<float>& im_info,
const std::vector<float>& anchors,
@@ -43,5 +42,4 @@ void generate_proposals_postprocessing(void* prois,
const Shape& output_scores_shape);
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

8
src/core/reference/include/openvino/reference/greater.hpp
View File

@@ -7,11 +7,10 @@
#include <cstddef>
#include "ngraph/op/util/attr_types.hpp"
#include "ngraph/runtime/reference/autobroadcast_binop.hpp"
#include "ngraph/shape.hpp"
#include "openvino/reference/autobroadcast_binop.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T>
void greater(const T* arg0,
@@ -36,5 +35,4 @@ void greater(const T* arg0,
});
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

8
src/core/reference/include/openvino/reference/greater_eq.hpp
View File

@@ -7,11 +7,10 @@
#include <cstddef>
#include "ngraph/op/util/attr_types.hpp"
#include "ngraph/runtime/reference/autobroadcast_binop.hpp"
#include "ngraph/shape.hpp"
#include "openvino/reference/autobroadcast_binop.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T>
void greater_eq(const T* arg0,
@@ -36,5 +35,4 @@ void greater_eq(const T* arg0,
});
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/grid_sample.hpp
View File

@@ -13,8 +13,7 @@
#include "ngraph/shape.hpp"
#include "openvino/op/grid_sample.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
namespace {
@@ -295,5 +294,4 @@ void grid_sample(DATA_ET* output,
std::fesetround(prev_rounding_mode);
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/grn.hpp
View File

@@ -6,13 +6,11 @@
#include "openvino/reference/normalize_l2.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T>
void grn(const T* data, T* out, float bias, const Shape& data_shape) {
normalize_l2(data, out, data_shape, {1}, bias, op::EpsMode::ADD);
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

26
src/core/reference/include/openvino/reference/group_convolution.hpp
View File

@@ -16,8 +16,7 @@ constexpr size_t out_batch_axis = 0;
constexpr size_t out_channel_axis = 1;
} // namespace
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
void validate_group_convolution_parameters(const Shape& in_shape,
const Shape& f_shape,
@@ -72,16 +71,16 @@ void group_convolution(const INPUT* in,
for (size_t batch_idx = 0; batch_idx < in_shape[in_batch_axis]; ++batch_idx) {
group_filter = f;
for (size_t group_idx = 0; group_idx < group_count; ++group_idx) {
runtime::reference::convolution(group_batch,
group_filter,
group_out,
group_batch_shape,
group_filter_shape,
group_out_shape,
strides,
dilation,
pads_begin,
pads_end);
reference::convolution(group_batch,
group_filter,
group_out,
group_batch_shape,
group_filter_shape,
group_out_shape,
strides,
dilation,
pads_begin,
pads_end);
group_batch += group_batch_size;
group_filter += group_filter_size;
group_out += group_out_size;
@@ -89,5 +88,4 @@ void group_convolution(const INPUT* in,
}
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

30
src/core/reference/include/openvino/reference/group_convolution_backprop_data.hpp
View File

@@ -7,8 +7,7 @@
#include "ngraph/util.hpp"
#include "openvino/reference/group_convolution.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
void infer_backward_conv_output_shape(const Shape& in_spatial_shape,
@@ -80,18 +79,18 @@ void group_convolution_backprop_data(const T* in,
for (size_t batch_idx = 0; batch_idx < in_shape[in_batch_axis]; ++batch_idx) {
group_filter = f;
for (size_t group_idx = 0; group_idx < group_count; ++group_idx) {
runtime::reference::convolution_backprop_in(group_batch,
group_filter,
group_out,
group_batch_shape,
group_filter_shape,
group_out_shape,
in_dilation,
dilation,
pads_begin,
pads_end,
strides,
output_padding);
reference::convolution_backprop_in(group_batch,
group_filter,
group_out,
group_batch_shape,
group_filter_shape,
group_out_shape,
in_dilation,
dilation,
pads_begin,
pads_end,
strides,
output_padding);
group_batch += group_batch_size;
group_filter += group_filter_size;
group_out += group_out_size;
@@ -129,5 +128,4 @@ void group_convolution_backprop_data(const INPUT* in,
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

1
src/core/reference/include/openvino/reference/group_normalization.hpp
View File

@@ -23,7 +23,6 @@ void group_normalization(const T* const data,
const size_t num_groups,
const double epsilon) {
using namespace std;
using namespace ngraph::runtime::reference;
const auto num_batches = data_shape[0];
const auto num_channels = data_shape[1];

6
src/core/reference/include/openvino/reference/gru_cell.hpp
View File

@@ -16,8 +16,7 @@
#include "openvino/reference/subtract.hpp"
#include "openvino/reference/tanh.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T>
void gru_cell(const T* X,
@@ -216,5 +215,4 @@ void gru_cell(const T* X,
reference::add(mul1.data(), mul2.data(), dst_data, gate_shape, gate_shape, op::AutoBroadcastType::NUMPY);
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/hard_sigmoid.hpp
View File

@@ -7,8 +7,7 @@
#include <cmath>
#include <cstddef>
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T>
void hard_sigmoid(const T* arg, const T alpha, const T beta, T* out, size_t count) {
@@ -17,5 +16,4 @@ void hard_sigmoid(const T* arg, const T alpha, const T beta, T* out, size_t coun
}
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/helpers.hpp
View File

@@ -4,8 +4,7 @@
#pragma once
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T>
struct widen {
@@ -22,5 +21,4 @@ struct widen<double> {
using type = long double;
};
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/hsigmoid.hpp
View File

@@ -7,8 +7,7 @@
#include <cmath>
#include <cstddef>
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T>
void hsigmoid(const T* arg, T* out, size_t count) {
@@ -17,5 +16,4 @@ void hsigmoid(const T* arg, T* out, size_t count) {
}
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/hswish.hpp
View File

@@ -7,8 +7,7 @@
#include <cmath>
#include <cstddef>
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T>
void hswish(const T* arg, T* out, size_t count) {
@@ -17,5 +16,4 @@ void hswish(const T* arg, T* out, size_t count) {
}
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

14
src/core/reference/include/openvino/reference/if.hpp
View File

@@ -6,16 +6,14 @@
#include <cmath>
#include "ngraph/op/util/multi_subgraph_base.hpp"
#include "openvino/op/util/multi_subgraph_base.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
void if_reference(const std::vector<std::shared_ptr<Function>>& body,
const std::vector<op::util::MultiSubgraphOutputDescriptionVector>& out_descs,
const std::vector<op::util::MultiSubgraphInputDescriptionVector>& input_descs,
void if_reference(const std::vector<std::shared_ptr<Model>>& body,
const std::vector<op::util::MultiSubGraphOp::MultiSubgraphOutputDescriptionVector>& out_descs,
const std::vector<op::util::MultiSubGraphOp::MultiSubgraphInputDescriptionVector>& input_descs,
const HostTensorVector& out,
const HostTensorVector& args);
}
} // namespace runtime
} // namespace ngraph
} // namespace ov

8
src/core/reference/include/openvino/reference/interpolate.hpp
View File

@@ -13,13 +13,12 @@
#include <map>
#include "interpolate_pil.hpp"
#include "ngraph/coordinate_transform.hpp"
#include "ngraph/op/interpolate.hpp"
#include "ngraph/shape_util.hpp"
#include "openvino/reference/utils/coordinate_transform.hpp"
#include "transpose.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
using Nearest_mode = ngraph::op::v4::Interpolate::NearestMode;
using Transform_mode = ngraph::op::v4::Interpolate::CoordinateTransformMode;
@@ -831,5 +830,4 @@ void interpolate(T* input_data,
evaluator(reinterpret_cast<T*>(padded_data_ptr), padded_input_shape, scales, axes, out, out_shape);
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/interpolate_pil.hpp
View File

@@ -44,8 +44,7 @@
#include "ngraph/op/interpolate.hpp"
#include "ngraph/shape_util.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
namespace interpolate_pil {
@@ -316,5 +315,4 @@ void imaging_resample_inner(const T* im_in,
} // namespace interpolate_pil
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/irdft.hpp
View File

@@ -8,8 +8,7 @@
#include "ngraph/shape.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
void irdft(const std::vector<float>& input_data,
const Shape& input_data_shape,
@@ -19,5 +18,4 @@ void irdft(const std::vector<float>& input_data,
const Shape& irdft_output_shape,
const int64_t last_signal_size);
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/is_finite.hpp
View File

@@ -7,8 +7,7 @@
#include <cmath>
#include <cstddef>
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T, typename U>
typename std::enable_if<std::is_floating_point<T>::value, void>::type is_finite(const T* input,
@@ -28,5 +27,4 @@ typename std::enable_if<std::is_class<T>::value, void>::type is_finite(const T*
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/is_inf.hpp
View File

@@ -7,8 +7,7 @@
#include <cmath>
#include <cstddef>
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T, typename U>
typename std::enable_if<std::is_floating_point<T>::value, void>::type
@@ -54,5 +53,4 @@ typename std::enable_if<std::is_class<T>::value, void>::type is_inf(const T* inp
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/is_nan.hpp
View File

@@ -7,8 +7,7 @@
#include <cmath>
#include <cstddef>
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T, typename U>
typename std::enable_if<std::is_floating_point<T>::value, void>::type is_nan(const T* input, U* output, size_t count) {
@@ -25,5 +24,4 @@ typename std::enable_if<std::is_class<T>::value, void>::type is_nan(const T* inp
});
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

8
src/core/reference/include/openvino/reference/less.hpp
View File

@@ -7,11 +7,10 @@
#include <cstddef>
#include "ngraph/op/util/attr_types.hpp"
#include "ngraph/runtime/reference/autobroadcast_binop.hpp"
#include "ngraph/shape.hpp"
#include "openvino/reference/autobroadcast_binop.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T>
void less(const T* arg0,
@@ -36,5 +35,4 @@ void less(const T* arg0,
});
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

8
src/core/reference/include/openvino/reference/less_eq.hpp
View File

@@ -7,11 +7,10 @@
#include <cstddef>
#include "ngraph/op/util/attr_types.hpp"
#include "ngraph/runtime/reference/autobroadcast_binop.hpp"
#include "ngraph/shape.hpp"
#include "openvino/reference/autobroadcast_binop.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T>
void less_eq(const T* arg0,
@@ -36,5 +35,4 @@ void less_eq(const T* arg0,
});
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/log.hpp
View File

@@ -7,8 +7,7 @@
#include <cmath>
#include <cstddef>
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T>
void log(const T* arg, T* out, size_t count) {
@@ -17,5 +16,4 @@ void log(const T* arg, T* out, size_t count) {
}
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

14
src/core/reference/include/openvino/reference/log_softmax.hpp
View File

@@ -6,18 +6,17 @@
#include <cmath>
#include "ngraph/coordinate_transform.hpp"
#include "ngraph/shape_util.hpp"
#include "openvino/reference/max.hpp"
#include "openvino/reference/sum.hpp"
#include "openvino/reference/utils/coordinate_transform.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T>
void log_softmax(const T* arg, T* out, const Shape& shape, const AxisSet& axes) {
NGRAPH_SUPPRESS_DEPRECATED_START
auto temp_shape = reduce(shape, axes, true);
auto temp_shape = ngraph::reduce(shape, axes, true);
auto temp_elements = shape_size(temp_shape);
auto temp_max = std::vector<T>(temp_elements, 0);
auto temp_sum = std::vector<T>(temp_elements, 0);
@@ -27,7 +26,7 @@ void log_softmax(const T* arg, T* out, const Shape& shape, const AxisSet& axes)
CoordinateTransform transform(shape);
CoordinateTransform temp_transform(temp_shape);
for (const Coordinate& coord : transform) {
Coordinate temp_coord = reduce(coord, axes, true);
Coordinate temp_coord = ngraph::reduce(coord, axes, true);
out[transform.index(coord)] =
static_cast<T>(std::exp(arg[transform.index(coord)] - temp_max[temp_transform.index(temp_coord)]));
}
@@ -35,7 +34,7 @@ void log_softmax(const T* arg, T* out, const Shape& shape, const AxisSet& axes)
sum(out, temp_sum.data(), shape, axes);
for (const Coordinate& coord : transform) {
Coordinate temp_coord = reduce(coord, axes, true);
Coordinate temp_coord = ngraph::reduce(coord, axes, true);
out[transform.index(coord)] =
static_cast<T>((arg[transform.index(coord)] - temp_max[temp_transform.index(temp_coord)]) -
std::log(temp_sum[temp_transform.index(temp_coord)]));
@@ -43,5 +42,4 @@ void log_softmax(const T* arg, T* out, const Shape& shape, const AxisSet& axes)
NGRAPH_SUPPRESS_DEPRECATED_END
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

16
src/core/reference/include/openvino/reference/logical_reduction.hpp
View File

@@ -7,11 +7,10 @@
#include <cmath>
#include <numeric>
#include "ngraph/coordinate_transform.hpp"
#include "ngraph/shape_util.hpp"
#include "openvino/reference/utils/coordinate_transform.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
OPENVINO_SUPPRESS_DEPRECATED_START
static inline void reduce_logical_and(const char* arg,
@@ -19,7 +18,7 @@ static inline void reduce_logical_and(const char* arg,
const Shape& in_shape,
const AxisSet& reduction_axes) {
constexpr bool dont_keep_dims_in_output = false;
const auto out_shape = reduce(in_shape, reduction_axes, dont_keep_dims_in_output);
const auto out_shape = ngraph::reduce(in_shape, reduction_axes, dont_keep_dims_in_output);
std::fill(out, out + shape_size(out_shape), 1);
const auto in_strides = row_major_strides(in_shape);
@@ -27,7 +26,7 @@ static inline void reduce_logical_and(const char* arg,
CoordinateTransformBasic input_transform(in_shape);
for (const Coordinate& input_coord : input_transform) {
const Coordinate output_coord = reduce(input_coord, reduction_axes, dont_keep_dims_in_output);
const Coordinate output_coord = ngraph::reduce(input_coord, reduction_axes, dont_keep_dims_in_output);
const size_t in_idx =
std::inner_product(input_coord.begin(), input_coord.end(), in_strides.begin(), uint64_t(0));
@@ -39,7 +38,7 @@ static inline void reduce_logical_and(const char* arg,
}
static inline void reduce_logical_or(const char* arg, char* out, const Shape& in_shape, const AxisSet& reduction_axes) {
const auto out_shape = reduce(in_shape, reduction_axes, false);
const auto out_shape = ngraph::reduce(in_shape, reduction_axes, false);
std::fill(out, out + shape_size(out_shape), 0);
const auto in_strides = row_major_strides(in_shape);
@@ -47,7 +46,7 @@ static inline void reduce_logical_or(const char* arg, char* out, const Shape& in
CoordinateTransformBasic input_transform(in_shape);
for (const Coordinate& input_coord : input_transform) {
const Coordinate output_coord = reduce(input_coord, reduction_axes, false);
const Coordinate output_coord = ngraph::reduce(input_coord, reduction_axes, false);
const size_t in_idx =
std::inner_product(input_coord.begin(), input_coord.end(), in_strides.begin(), uint64_t(0));
@@ -59,5 +58,4 @@ static inline void reduce_logical_or(const char* arg, char* out, const Shape& in
}
OPENVINO_SUPPRESS_DEPRECATED_END
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

14
src/core/reference/include/openvino/reference/loop.hpp
View File

@@ -5,17 +5,17 @@
#pragma once
#include <cmath>
#include <ngraph/opsets/opset5.hpp>
namespace ngraph {
namespace runtime {
#include "openvino/op/loop.hpp"
#include "openvino/op/util/sub_graph_base.hpp"
namespace ov {
namespace reference {
void loop(const std::shared_ptr<Function>& body,
void loop(const std::shared_ptr<Model>& body,
const op::util::OutputDescriptionVector& out_descs,
const op::util::InputDescriptionVector& input_descs,
const opset5::Loop::SpecialBodyPorts& special_ports,
const op::v5::Loop::SpecialBodyPorts& special_ports,
const HostTensorVector& out,
const HostTensorVector& args);
}
} // namespace runtime
} // namespace ngraph
} // namespace ov

8
src/core/reference/include/openvino/reference/lrn.hpp
View File

@@ -8,11 +8,10 @@
#include <cmath>
#include <numeric>
#include "ngraph/coordinate_transform.hpp"
#include "ngraph/util.hpp"
#include "openvino/reference/utils/coordinate_transform.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
static size_t point_to_flat_idx(const Shape& shape, const std::vector<size_t>& point) {
size_t idx = point[0];
@@ -97,5 +96,4 @@ void lrn(const T* arg,
NGRAPH_SUPPRESS_DEPRECATED_END
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/lstm_cell.hpp
View File

@@ -16,8 +16,7 @@
#include "openvino/reference/subtract.hpp"
#include "openvino/reference/tanh.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T>
void lstm_cell(const T* X,
@@ -365,5 +364,4 @@ void lstm_cell_v1(const T* X,
reference::multiply(XHBPo.data(), Ct.data(), out_Ht, gate_shape, gate_shape, op::AutoBroadcastType::NUMPY);
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

30
src/core/reference/include/openvino/reference/matmul.hpp
View File

@@ -13,8 +13,7 @@
#include "ngraph/shape_util.hpp"
#include "openvino/reference/broadcast.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
namespace details {
template <typename T>
@@ -102,12 +101,12 @@ void matmul(const T* arg0,
std::vector<T> tmp(shape_size(arg0_shape));
auto axis_vector = details::get_transpose_order(arg0_shape);
std::swap(arg0_shape_tmp[arg0_rank - 1], arg0_shape_tmp[arg0_rank - 2]);
opt_kernel::reshape(reinterpret_cast<const char*>(arg0_data),
reinterpret_cast<char*>(tmp.data()),
arg0_shape,
axis_vector,
arg0_shape_tmp,
sizeof(T));
ngraph::runtime::opt_kernel::reshape(reinterpret_cast<const char*>(arg0_data),
reinterpret_cast<char*>(tmp.data()),
arg0_shape,
axis_vector,
arg0_shape_tmp,
sizeof(T));
arg0_new_data.swap(tmp);
arg0_data = arg0_new_data.data();
}
@@ -116,12 +115,12 @@ void matmul(const T* arg0,
std::vector<T> tmp(shape_size(arg1_shape));
auto axis_vector = details::get_transpose_order(arg1_shape);
std::swap(arg1_shape_tmp[arg1_rank - 1], arg1_shape_tmp[arg1_rank - 2]);
opt_kernel::reshape(reinterpret_cast<const char*>(arg1_data),
reinterpret_cast<char*>(tmp.data()),
arg1_shape,
axis_vector,
arg1_shape_tmp,
sizeof(T));
ngraph::runtime::opt_kernel::reshape(reinterpret_cast<const char*>(arg1_data),
reinterpret_cast<char*>(tmp.data()),
arg1_shape,
axis_vector,
arg1_shape_tmp,
sizeof(T));
arg1_new_data.swap(tmp);
arg1_data = arg1_new_data.data();
}
@@ -218,5 +217,4 @@ void matmul(const T* arg0,
}
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/matrix_nms.hpp
View File

@@ -19,8 +19,7 @@
#include "ngraph/op/util/op_types.hpp"
#include "ngraph/shape_util.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
void matrix_nms(const float* boxes_data,
const Shape& boxes_data_shape,
@@ -34,5 +33,4 @@ void matrix_nms(const float* boxes_data,
int64_t* valid_outputs);
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

12
src/core/reference/include/openvino/reference/max.hpp
View File

@@ -8,11 +8,10 @@
#include <limits>
#include <numeric>
#include "ngraph/coordinate_transform.hpp"
#include "ngraph/shape_util.hpp"
#include "openvino/reference/utils/coordinate_transform.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T>
void max(const T* arg, T* out, const Shape& in_shape, const AxisSet& reduction_axes) {
@@ -20,7 +19,7 @@ void max(const T* arg, T* out, const Shape& in_shape, const AxisSet& reduction_a
constexpr bool dont_keep_dims_in_output = false;
OPENVINO_SUPPRESS_DEPRECATED_START
const auto out_shape = reduce(in_shape, reduction_axes, dont_keep_dims_in_output);
const auto out_shape = ngraph::reduce(in_shape, reduction_axes, dont_keep_dims_in_output);
std::fill(out, out + shape_size(out_shape), minval);
const auto in_strides = row_major_strides(in_shape);
@@ -28,7 +27,7 @@ void max(const T* arg, T* out, const Shape& in_shape, const AxisSet& reduction_a
CoordinateTransformBasic input_transform(in_shape);
for (const Coordinate& input_coord : input_transform) {
const Coordinate output_coord = reduce(input_coord, reduction_axes, dont_keep_dims_in_output);
const Coordinate output_coord = ngraph::reduce(input_coord, reduction_axes, dont_keep_dims_in_output);
const size_t in_idx =
std::inner_product(input_coord.begin(), input_coord.end(), in_strides.begin(), uint64_t(0));
@@ -44,5 +43,4 @@ void max(const T* arg, T* out, const Shape& in_shape, const AxisSet& reduction_a
OPENVINO_SUPPRESS_DEPRECATED_END
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

8
src/core/reference/include/openvino/reference/max_pool.hpp
View File

@@ -7,10 +7,9 @@
#include <cmath>
#include <numeric>
#include "ngraph/coordinate_transform.hpp"
#include "openvino/reference/utils/coordinate_transform.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T>
void max_pool(const T* arg,
@@ -411,5 +410,4 @@ void max_pool(const Values_t* data,
}
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

8
src/core/reference/include/openvino/reference/maximum.hpp
View File

@@ -7,11 +7,10 @@
#include <cstddef>
#include "ngraph/op/util/attr_types.hpp"
#include "ngraph/runtime/reference/autobroadcast_binop.hpp"
#include "ngraph/shape.hpp"
#include "openvino/reference/autobroadcast_binop.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T>
void maximum(const T* arg0, const T* arg1, T* out, size_t count) {
@@ -32,5 +31,4 @@ void maximum(const T* arg0,
});
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

12
src/core/reference/include/openvino/reference/mean.hpp
View File

@@ -9,20 +9,19 @@
#include <numeric>
#include <vector>
#include "ngraph/coordinate_transform.hpp"
#include "ngraph/shape_util.hpp"
#include "ngraph/type/bfloat16.hpp"
#include "ngraph/type/float16.hpp"
#include "openvino/reference/sum.hpp"
#include "openvino/reference/utils/coordinate_transform.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T>
void mean(const T* arg, T* out, const Shape& in_shape, const AxisSet& reduction_axes) {
constexpr bool dont_keep_dims_in_output = false;
OPENVINO_SUPPRESS_DEPRECATED_START
const auto out_shape = reduce(in_shape, reduction_axes, dont_keep_dims_in_output);
const auto out_shape = ngraph::reduce(in_shape, reduction_axes, dont_keep_dims_in_output);
std::vector<T> cs(shape_size(out_shape), 0);
std::fill(out, out + shape_size(out_shape), T(0));
@@ -33,7 +32,7 @@ void mean(const T* arg, T* out, const Shape& in_shape, const AxisSet& reduction_
std::map<size_t, int> index_to_count_map;
for (const Coordinate& input_coord : input_transform) {
const Coordinate output_coord = reduce(input_coord, reduction_axes, dont_keep_dims_in_output);
const Coordinate output_coord = ngraph::reduce(input_coord, reduction_axes, dont_keep_dims_in_output);
const size_t in_idx =
std::inner_product(input_coord.begin(), input_coord.end(), in_strides.begin(), uint64_t(0));
@@ -56,5 +55,4 @@ void mean(const T* arg, T* out, const Shape& in_shape, const AxisSet& reduction_
}
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

12
src/core/reference/include/openvino/reference/min.hpp
View File

@@ -8,15 +8,14 @@
#include <limits>
#include <numeric>
#include "ngraph/coordinate_transform.hpp"
#include "ngraph/shape_util.hpp"
#include "openvino/reference/utils/coordinate_transform.hpp"
#ifdef _WIN32
# undef min
#endif
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T>
void min(const T* arg, T* out, const Shape& in_shape, const AxisSet& reduction_axes) {
@@ -25,7 +24,7 @@ void min(const T* arg, T* out, const Shape& in_shape, const AxisSet& reduction_a
constexpr bool dont_keep_dims_in_output = false;
OPENVINO_SUPPRESS_DEPRECATED_START
const auto out_shape = reduce(in_shape, reduction_axes, dont_keep_dims_in_output);
const auto out_shape = ngraph::reduce(in_shape, reduction_axes, dont_keep_dims_in_output);
std::fill(out, out + shape_size(out_shape), minval);
const auto in_strides = row_major_strides(in_shape);
@@ -33,7 +32,7 @@ void min(const T* arg, T* out, const Shape& in_shape, const AxisSet& reduction_a
CoordinateTransformBasic input_transform(in_shape);
for (const Coordinate& input_coord : input_transform) {
const Coordinate output_coord = reduce(input_coord, reduction_axes, dont_keep_dims_in_output);
const Coordinate output_coord = ngraph::reduce(input_coord, reduction_axes, dont_keep_dims_in_output);
const size_t in_idx =
std::inner_product(input_coord.begin(), input_coord.end(), in_strides.begin(), uint64_t(0));
@@ -49,5 +48,4 @@ void min(const T* arg, T* out, const Shape& in_shape, const AxisSet& reduction_a
OPENVINO_SUPPRESS_DEPRECATED_END
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

8
src/core/reference/include/openvino/reference/minimum.hpp
View File

@@ -7,11 +7,10 @@
#include <cstddef>
#include "ngraph/op/util/attr_types.hpp"
#include "ngraph/runtime/reference/autobroadcast_binop.hpp"
#include "ngraph/shape.hpp"
#include "openvino/reference/autobroadcast_binop.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T>
void minimum(const T* arg0, const T* arg1, T* out, size_t count) {
@@ -32,5 +31,4 @@ void minimum(const T* arg0,
});
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/mish.hpp
View File

@@ -7,8 +7,7 @@
#include <cmath>
#include <cstddef>
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T>
void mish(const T* arg, T* out, size_t count) {
@@ -17,5 +16,4 @@ void mish(const T* arg, T* out, size_t count) {
}
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

8
src/core/reference/include/openvino/reference/mod.hpp
View File

@@ -7,10 +7,9 @@
#include <cmath>
#include <cstddef>
#include "ngraph/runtime/reference/autobroadcast_binop.hpp"
#include "openvino/reference/autobroadcast_binop.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
template <typename T>
void mod(const T* arg0,
@@ -24,5 +23,4 @@ void mod(const T* arg0,
});
}
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

6
src/core/reference/include/openvino/reference/multiclass_nms.hpp
View File

@@ -19,8 +19,7 @@
#include "ngraph/op/util/op_types.hpp"
#include "ngraph/shape_util.hpp"
namespace ngraph {
namespace runtime {
namespace ov {
namespace reference {
void multiclass_nms(const float* boxes_data,
@@ -37,5 +36,4 @@ void multiclass_nms(const float* boxes_data,
int64_t* valid_outputs);
} // namespace reference
} // namespace runtime
} // namespace ngraph
} // namespace ov

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