Skip to content

Commit f6eb6af

Browse files
nkogtevankogteva
authoredOct 12, 2023
Move Convolution and GroupConvolution layer tests to API 2.0 (#747)
1 parent b21bc7c commit f6eb6af

File tree

7 files changed

+2555
-3864
lines changed

7 files changed

+2555
-3864
lines changed
 

‎modules/nvidia_plugin/tests/functional/shared_tests_instances/single_layer_tests/convolution.cpp

+1,264-2,848
Large diffs are not rendered by default.

‎modules/nvidia_plugin/tests/functional/shared_tests_instances/single_layer_tests/convolution_asym_pad.cpp

-48
This file was deleted.

‎modules/nvidia_plugin/tests/functional/shared_tests_instances/single_layer_tests/group_convolution.cpp

+805-35
Large diffs are not rendered by default.

‎modules/nvidia_plugin/tests/functional/shared_tests_instances/single_layer_tests/group_convolution_autogenerated.cpp

-933
This file was deleted.

‎modules/nvidia_plugin/tests/functional/shared_tests_instances/single_layer_tests/ov_average_finder.hpp

+137
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,137 @@
1+
// Copyright (C) 2021-2023 Intel Corporation
2+
// SPDX-License-Identifier: Apache-2.0
3+
//
4+
5+
#pragma once
6+
7+
#include <error.hpp>
8+
9+
#include "shared_test_classes/base/ov_subgraph.hpp"
10+
11+
namespace ov {
12+
namespace test {
13+
14+
namespace details {
15+
16+
template <typename T>
17+
static T find_average(const T* ptr, const size_t size) {
18+
const auto abs_sum =
19+
std::accumulate(ptr, ptr + size, float(0.0f), [](float a, T b) {return std::abs(a) + std::abs(static_cast<float>(b)); });
20+
const T average = static_cast<T>(abs_sum / size);
21+
std::cout << "average absolute :" << average << '\n';
22+
return average;
23+
}
24+
25+
struct BlobLimits {
26+
float min = std::numeric_limits<float>::max();
27+
float max = std::numeric_limits<float>::min();
28+
float avg = 0.0f;
29+
float abs_min = std::numeric_limits<float>::max();
30+
float abs_max = 0.0f;
31+
float abs_avg = 0.0f;
32+
};
33+
34+
template <typename T>
35+
static BlobLimits find_limits(const T* output, const size_t size, BlobLimits& bl) {
36+
bl = BlobLimits{};
37+
const auto* ptr = output;
38+
float sum = 0.0f;
39+
float abs_sum = 0.0f;
40+
for (size_t i = 0; i < size; ++i) {
41+
const auto el = static_cast<float>(ptr[i]);
42+
const auto abs_el = std::abs(el);
43+
bl.min = el < bl.min ? el : bl.min;
44+
bl.max = el > bl.max ? el : bl.max;
45+
bl.abs_min = abs_el < bl.abs_min ? abs_el : bl.abs_min;
46+
bl.abs_max = abs_el > bl.abs_max ? abs_el : bl.abs_max;
47+
sum += el;
48+
abs_sum += abs_el;
49+
}
50+
bl.avg = sum / size;
51+
bl.abs_avg = abs_sum / size;
52+
53+
std::cout << "min = " << bl.min << ", max = " << bl.max << ", avg = " << bl.avg << '\n';
54+
std::cout << "abs_min = " << bl.abs_min << ", abs_max = " << bl.abs_max << ", abs_avg = " << bl.abs_avg << '\n';
55+
56+
return bl;
57+
}
58+
59+
} // namespace details
60+
61+
/**
62+
* @brief This class is the base class for AverageFinder class.
63+
* It is used to set the threshold for SubgraphBaseTest::comapare() functions
64+
* accordingly to the average absolute value of the reference output of a single layer test class.
65+
* To use it, threshold_base should be set in the derived class.
66+
* threshold = average * threshold_base
67+
* For now can be used only for the operations with one output.
68+
*/
69+
class AverageFinderBase : virtual public SubgraphBaseTest {
70+
virtual std::vector<ov::Tensor> calculate_refs() override {
71+
using namespace details;
72+
const auto ref_outputs = SubgraphBaseTest::calculate_refs();
73+
if (ref_outputs.size() == 1) {
74+
const auto& type = ref_outputs[0].get_element_type();
75+
float average;
76+
if (type == ov::element::Type_t::f32) {
77+
average = find_average(ref_outputs[0].data<float>(), ref_outputs[0].get_size());
78+
} else if (type == ov::element::Type_t::f16) {
79+
average = find_average(ref_outputs[0].data<ov::float16>(), ref_outputs[0].get_size());
80+
} else {
81+
ov::nvidia_gpu::throw_ov_exception(std::string{"Unsupported type: "} + type.get_type_name());
82+
}
83+
if (!isinf(average))
84+
abs_threshold = average * threshold_base;
85+
std::cout << "threshold = " << abs_threshold << '\n';
86+
}
87+
return ref_outputs;
88+
}
89+
90+
protected:
91+
float threshold_base = 0.0f;
92+
};
93+
94+
/**
95+
* @brief This class is the actual base class that should be used for the derived test class.
96+
*/
97+
template <typename BaseLayerTest>
98+
class AverageFinder : public BaseLayerTest, public AverageFinderBase {
99+
static_assert(std::is_base_of_v<SubgraphBaseTest, BaseLayerTest>,
100+
"BaseLayerTest should be derived from ov::test::SubgraphBaseTest");
101+
};
102+
103+
/**
104+
* @brief This class is the base class for MinMaxAvgFinder class.
105+
* It is used to find and print min, max, average, min absolute, max absolute and average absolute values for the
106+
* single layer test class with one output.
107+
*/
108+
class MinMaxAvgFinderBase : virtual public SubgraphBaseTest {
109+
virtual std::vector<ov::Tensor> calculate_refs() override {
110+
using namespace details;
111+
const auto ref_outputs = SubgraphBaseTest::calculate_refs();
112+
if (ref_outputs.size() == 1) {
113+
const auto& type = ref_outputs[0].get_element_type();
114+
BlobLimits bl;
115+
if (type == ov::element::Type_t::f32) {
116+
find_limits(ref_outputs[0].data<float>(), ref_outputs[0].get_size(), bl);
117+
} else if (type == ov::element::Type_t::f16) {
118+
find_limits(ref_outputs[0].data<ov::float16>(), ref_outputs[0].get_size(), bl);
119+
} else {
120+
ov::nvidia_gpu::throw_ov_exception(std::string{"Unsupported type: "} + type.get_type_name());
121+
}
122+
}
123+
return ref_outputs;
124+
}
125+
};
126+
127+
/**
128+
* @brief This class is the actual base class that should be used for the derived test class.
129+
*/
130+
template <typename BaseLayerTest>
131+
class MinMaxAvgFinder : public BaseLayerTest, public MinMaxAvgFinderBase {
132+
static_assert(std::is_base_of_v<SubgraphBaseTest, BaseLayerTest>,
133+
"BaseLayerTest should be derived from ov::test::SubgraphBaseTest");
134+
};
135+
136+
} // namespace test
137+
} // namespace ov

‎modules/nvidia_plugin/tests/functional/shared_tests_instances/single_layer_tests/ov_finite_comparer.cpp

+153
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,153 @@
1+
// Copyright (C) 2022-2023 Intel Corporation
2+
// SPDX-License-Identifier: Apache-2.0
3+
//
4+
5+
#include "ov_finite_comparer.hpp"
6+
#include "ov_models/utils/ov_helpers.hpp"
7+
8+
using namespace ov::test;
9+
10+
void ov::test::FiniteLayerComparer::compare(const std::vector<ov::Tensor>& expected_outputs,
11+
const std::vector<ov::Tensor>& actual_outputs,
12+
float threshold,
13+
bool to_check_nans,
14+
std::optional<double> infinity_value) {
15+
for (std::size_t output_iIndex = 0; output_iIndex < expected_outputs.size(); ++output_iIndex) {
16+
const auto& expected = expected_outputs[output_iIndex];
17+
const auto& actual = actual_outputs[output_iIndex];
18+
FiniteLayerComparer::compare(expected, actual, threshold, to_check_nans, infinity_value);
19+
}
20+
}
21+
22+
template <typename T_IE>
23+
inline void call_compare(const ov::Tensor& expected,
24+
const T_IE* actual_buffer,
25+
size_t size,
26+
float threshold,
27+
bool to_check_nans,
28+
std::optional<double> infinity_value) {
29+
const auto& precision = expected.get_element_type();
30+
switch (precision) {
31+
case ov::element::Type_t::i64:
32+
FiniteLayerComparer::compare<T_IE>(
33+
expected.data<int64_t>(), actual_buffer, size, threshold, to_check_nans, infinity_value);
34+
break;
35+
case ov::element::Type_t::i32:
36+
FiniteLayerComparer::compare<T_IE>(
37+
expected.data<int32_t>(), actual_buffer, size, threshold, to_check_nans, infinity_value);
38+
break;
39+
case ov::element::Type_t::i16:
40+
FiniteLayerComparer::compare<T_IE>(
41+
expected.data<int16_t>(), actual_buffer, size, threshold, to_check_nans, infinity_value);
42+
break;
43+
case ov::element::Type_t::i8:
44+
FiniteLayerComparer::compare<T_IE>(
45+
expected.data<int8_t>(), actual_buffer, size, threshold, to_check_nans, infinity_value);
46+
break;
47+
case ov::element::Type_t::u64:
48+
FiniteLayerComparer::compare<T_IE>(
49+
expected.data<uint64_t>(), actual_buffer, size, threshold, to_check_nans, infinity_value);
50+
break;
51+
case ov::element::Type_t::u32:
52+
FiniteLayerComparer::compare<T_IE>(
53+
expected.data<uint32_t>(), actual_buffer, size, threshold, to_check_nans, infinity_value);
54+
break;
55+
case ov::element::Type_t::u16:
56+
FiniteLayerComparer::compare<T_IE>(
57+
expected.data<uint16_t>(), actual_buffer, size, threshold, to_check_nans, infinity_value);
58+
break;
59+
case ov::element::Type_t::boolean:
60+
case ov::element::Type_t::u8:
61+
FiniteLayerComparer::compare<T_IE>(
62+
expected.data<uint8_t>(), actual_buffer, size, threshold, to_check_nans, infinity_value);
63+
break;
64+
case ov::element::Type_t::f64:
65+
FiniteLayerComparer::compare<T_IE>(
66+
expected.data<double>(), actual_buffer, size, threshold, to_check_nans, infinity_value);
67+
break;
68+
case ov::element::Type_t::f32:
69+
FiniteLayerComparer::compare<T_IE>(
70+
expected.data<float>(), actual_buffer, size, threshold, to_check_nans, infinity_value);
71+
break;
72+
case ov::element::Type_t::f16:
73+
FiniteLayerComparer::compare<T_IE>(
74+
expected.data<ov::float16>(), actual_buffer, size, threshold, to_check_nans, infinity_value);
75+
break;
76+
case ov::element::Type_t::bf16:
77+
FiniteLayerComparer::compare<T_IE>(
78+
expected.data<ov::bfloat16>(), actual_buffer, size, threshold, to_check_nans, infinity_value);
79+
break;
80+
case ov::element::Type_t::dynamic:
81+
case ov::element::Type_t::undefined:
82+
FiniteLayerComparer::compare<T_IE, T_IE>(
83+
expected.data<T_IE>(), actual_buffer, size, threshold, to_check_nans, infinity_value);
84+
break;
85+
default:
86+
FAIL() << "Comparator for " << precision << " precision isn't supported";
87+
}
88+
return;
89+
}
90+
91+
void FiniteLayerComparer::compare(const ov::Tensor& expected,
92+
const ov::Tensor& actual,
93+
float threshold,
94+
bool to_check_nans,
95+
std::optional<double> infinity_value) {
96+
const auto& precision = actual.get_element_type();
97+
auto k = static_cast<float>(expected.get_element_type().size()) / precision.size();
98+
// W/A for int4, uint4
99+
if (expected.get_element_type() == ov::element::Type_t::u4 ||
100+
expected.get_element_type() == ov::element::Type_t::i4) {
101+
k /= 2;
102+
} else if (expected.get_element_type() == ov::element::Type_t::undefined ||
103+
expected.get_element_type() == ov::element::Type_t::dynamic) {
104+
k = 1;
105+
}
106+
ASSERT_EQ(expected.get_byte_size(), actual.get_byte_size() * k);
107+
108+
const auto& size = actual.get_size();
109+
switch (precision) {
110+
case ov::element::f32:
111+
call_compare(expected, actual.data<float>(), size, threshold, to_check_nans, infinity_value);
112+
break;
113+
case ov::element::i32:
114+
call_compare(expected, actual.data<int32_t>(), size, threshold, to_check_nans, infinity_value);
115+
break;
116+
case ov::element::u32:
117+
call_compare(expected, actual.data<uint32_t>(), size, threshold, to_check_nans, infinity_value);
118+
break;
119+
case ov::element::i64:
120+
call_compare(expected, actual.data<int64_t>(), size, threshold, to_check_nans, infinity_value);
121+
break;
122+
case ov::element::i8:
123+
call_compare(expected, actual.data<int8_t>(), size, threshold, to_check_nans, infinity_value);
124+
break;
125+
case ov::element::u16:
126+
call_compare(expected, actual.data<uint16_t>(), size, threshold, to_check_nans, infinity_value);
127+
break;
128+
case ov::element::i16:
129+
call_compare(expected, actual.data<int16_t>(), size, threshold, to_check_nans, infinity_value);
130+
break;
131+
case ov::element::boolean:
132+
case ov::element::u8:
133+
call_compare(expected, actual.data<uint8_t>(), size, threshold, to_check_nans, infinity_value);
134+
break;
135+
case ov::element::u64:
136+
call_compare(expected, actual.data<uint64_t>(), size, threshold, to_check_nans, infinity_value);
137+
break;
138+
case ov::element::bf16:
139+
call_compare(expected, actual.data<ov::bfloat16>(), size, threshold, to_check_nans, infinity_value);
140+
break;
141+
case ov::element::f16:
142+
call_compare(expected, actual.data<ov::float16>(), size, threshold, to_check_nans, infinity_value);
143+
break;
144+
default:
145+
FAIL() << "Comparator for " << precision << " precision isn't supported";
146+
}
147+
}
148+
149+
void ov::test::FiniteLayerComparer::compare(const std::vector<ov::Tensor>& expected_outputs,
150+
const std::vector<ov::Tensor>& actual_outputs) {
151+
FiniteLayerComparer::compare(
152+
expected_outputs, actual_outputs, abs_threshold, this->to_check_nans, this->infinity_value);
153+
}

0 commit comments

Comments
 (0)
Please sign in to comment.