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

Moved eval tests to new API (#19364)

Browse Source 
* Moved eval tests to new API

* Fixed build

* Fixed eval tests
This commit is contained in:
Ilya Churaev 2023-08-28 10:22:14 +04:00 committed by GitHub
parent b87709a8a7
commit 29ad3e8c92
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 1405 additions and 1209 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2530
src/core/tests/eval.cpp
View File

File diff suppressed because it is too large Load Diff

78
src/core/tests/utils/eval_utils.hpp
View File

@ -6,90 +6,93 @@
#include <random>
#include "gtest/gtest.h"
#include "ngraph/runtime/host_tensor.hpp"
#include "openvino/core/node.hpp"
#include "openvino/core/shape.hpp"
OPENVINO_SUPPRESS_DEPRECATED_START
namespace {
template <typename T>
void copy_data(const std::shared_ptr<ngraph::runtime::Tensor>& tv, const std::vector<T>& data) {
void copy_data(const ov::Tensor& tv, const std::vector<T>& data) {
size_t data_size = data.size() * sizeof(T);
if (data_size > 0) {
tv->write(data.data(), data_size);
OPENVINO_ASSERT(tv.get_byte_size() >= data_size);
memcpy(tv.data(), data.data(), data_size);
}
}
template <>
inline void copy_data<bool>(const std::shared_ptr<ngraph::runtime::Tensor>& tv, const std::vector<bool>& data) {
inline void copy_data<bool>(const ov::Tensor& tv, const std::vector<bool>& data) {
std::vector<char> data_char(data.begin(), data.end());
copy_data(tv, data_char);
}
template <typename T>
void init_int_tv(ngraph::runtime::Tensor* tv, std::default_random_engine& engine, T min, T max) {
size_t size = tv->get_element_count();
void init_int_tv(const ov::Tensor& tv, std::default_random_engine& engine, T min, T max) {
size_t size = tv.get_size();
std::uniform_int_distribution<T> dist(min, max);
std::vector<T> vec(size);
for (T& element : vec) {
element = dist(engine);
}
tv->write(vec.data(), vec.size() * sizeof(T));
size_t data_size = vec.size() * sizeof(T);
OPENVINO_ASSERT(tv.get_byte_size() >= data_size);
memcpy(tv.data(), vec.data(), data_size);
}
template <>
inline void init_int_tv<char>(ngraph::runtime::Tensor* tv, std::default_random_engine& engine, char min, char max) {
size_t size = tv->get_element_count();
inline void init_int_tv<char>(const ov::Tensor& tv, std::default_random_engine& engine, char min, char max) {
size_t size = tv.get_size();
std::uniform_int_distribution<int16_t> dist(static_cast<short>(min), static_cast<short>(max));
std::vector<char> vec(size);
for (char& element : vec) {
element = static_cast<char>(dist(engine));
}
tv->write(vec.data(), vec.size() * sizeof(char));
size_t data_size = vec.size() * sizeof(char);
OPENVINO_ASSERT(tv.get_byte_size() >= data_size);
memcpy(tv.data(), vec.data(), data_size);
}
template <>
inline void init_int_tv<int8_t>(ngraph::runtime::Tensor* tv,
std::default_random_engine& engine,
int8_t min,
int8_t max) {
size_t size = tv->get_element_count();
inline void init_int_tv<int8_t>(const ov::Tensor& tv, std::default_random_engine& engine, int8_t min, int8_t max) {
size_t size = tv.get_size();
std::uniform_int_distribution<int16_t> dist(static_cast<short>(min), static_cast<short>(max));
std::vector<int8_t> vec(size);
for (int8_t& element : vec) {
element = static_cast<int8_t>(dist(engine));
}
tv->write(vec.data(), vec.size() * sizeof(int8_t));
size_t data_size = vec.size() * sizeof(int8_t);
OPENVINO_ASSERT(tv.get_byte_size() >= data_size);
memcpy(tv.data(), vec.data(), data_size);
}
template <>
inline void init_int_tv<uint8_t>(ngraph::runtime::Tensor* tv,
std::default_random_engine& engine,
uint8_t min,
uint8_t max) {
size_t size = tv->get_element_count();
inline void init_int_tv<uint8_t>(const ov::Tensor& tv, std::default_random_engine& engine, uint8_t min, uint8_t max) {
size_t size = tv.get_size();
std::uniform_int_distribution<int16_t> dist(static_cast<short>(min), static_cast<short>(max));
std::vector<uint8_t> vec(size);
for (uint8_t& element : vec) {
element = static_cast<uint8_t>(dist(engine));
}
tv->write(vec.data(), vec.size() * sizeof(uint8_t));
size_t data_size = vec.size() * sizeof(uint8_t);
OPENVINO_ASSERT(tv.get_byte_size() >= data_size);
memcpy(tv.data(), vec.data(), data_size);
}
template <typename T>
void init_real_tv(ngraph::runtime::Tensor* tv, std::default_random_engine& engine, T min, T max) {
size_t size = tv->get_element_count();
void init_real_tv(const ov::Tensor& tv, std::default_random_engine& engine, T min, T max) {
size_t size = tv.get_size();
std::uniform_real_distribution<T> dist(min, max);
std::vector<T> vec(size);
for (T& element : vec) {
element = dist(engine);
}
tv->write(vec.data(), vec.size() * sizeof(T));
size_t data_size = vec.size() * sizeof(T);
OPENVINO_ASSERT(tv.get_byte_size() >= data_size);
memcpy(tv.data(), vec.data(), data_size);
}
inline void random_init(ngraph::runtime::Tensor* tv, std::default_random_engine& engine) {
ov::element::Type et = tv->get_element_type();
inline void random_init(const ov::Tensor& tv, std::default_random_engine& engine) {
ov::element::Type et = tv.get_element_type();
if (et == ov::element::boolean) {
init_int_tv<char>(tv, engine, 0, 1);
} else if (et == ov::element::f32) {
@ -119,19 +122,18 @@ inline void random_init(ngraph::runtime::Tensor* tv, std::default_random_engine&
} // namespace
template <ov::element::Type_t ET>
ngraph::HostTensorPtr make_host_tensor(const ov::Shape& shape,
ov::Tensor make_tensor(const ov::Shape& shape,
const std::vector<typename ov::element_type_traits<ET>::value_type>& data) {
OPENVINO_ASSERT(shape_size(shape) == data.size(), "Incorrect number of initialization elements");
auto host_tensor = std::make_shared<ngraph::runtime::HostTensor>(ET, shape);
copy_data(host_tensor, data);
return host_tensor;
auto tensor = ov::Tensor(ET, shape);
copy_data(tensor, data);
return tensor;
}
template <ov::element::Type_t ET>
ngraph::HostTensorPtr make_host_tensor(const ov::Shape& shape) {
auto host_tensor = std::make_shared<ngraph::runtime::HostTensor>(ET, shape);
ov::Tensor make_tensor(const ov::Shape& shape) {
auto tensor = ov::Tensor(ET, shape);
static std::default_random_engine engine(2112);
random_init(host_tensor.get(), engine);
return host_tensor;
random_init(tensor, engine);
return tensor;
}
OPENVINO_SUPPRESS_DEPRECATED_END