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

[GPU] Use ov element type and float16 inside plugin (#20110)

Browse Source
This commit is contained in:
Vladimir Paramuzov 2023-10-03 16:46:50 +04:00 committed by GitHub
parent 1178d983e6
commit a2c524019a
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
134 changed files with 4097 additions and 4511 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/plugins/intel_gpu/include/intel_gpu/primitives/generate_proposals.hpp
View File

@ -59,7 +59,7 @@ struct generate_proposals
int64_t post_nms_count = 0;
bool normalized = false;
float nms_eta = 0.0f;
data_types roi_num_type = data_types::bin;
data_types roi_num_type = data_types::undefined;
size_t hash() const override {
size_t seed = primitive::hash();

2
src/plugins/intel_gpu/include/intel_gpu/primitives/primitive.hpp
View File

@ -150,7 +150,7 @@ public:
return false;
for (size_t i = 0; i < output_data_types.size(); ++i) {
if (output_data_types[i].value_or(data_types::bin) != rhs.output_data_types[i].value_or(data_types::bin))
if (output_data_types[i].value_or(data_types::undefined) != rhs.output_data_types[i].value_or(data_types::undefined))
return false;
}

57
src/plugins/intel_gpu/include/intel_gpu/runtime/half.hpp
View File

@ -1,57 +0,0 @@
// Copyright (C) 2018-2023 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#pragma once
#include <stdint.h>
#include <stddef.h>
#include <memory>
#include <string>
#include <type_traits>
namespace cldnn {
/// @addtogroup cpp_api C++ API
/// @{
float half_to_float(uint16_t value);
uint16_t float_to_half(float value);
// There is no portable half precision floating point support.
// Using wrapped integral type with the same size and alignment restrictions.
class half_impl {
public:
half_impl() = default;
template <typename T, typename = typename std::enable_if<!std::is_floating_point<T>::value>::type>
explicit half_impl(T data, int /*direct_creation_tag*/) : _data(data) {}
operator uint16_t() const { return _data; }
operator int32_t() const { return static_cast<int32_t>(half_to_float(_data)); }
operator int64_t() const { return static_cast<int64_t>(half_to_float(_data)); }
operator float() const {
return half_to_float(_data);
}
explicit half_impl(float value)
: _data(float_to_half(value))
{}
template <typename T, typename = typename std::enable_if<std::is_convertible<T, float>::value>::type>
explicit half_impl(T value)
: half_impl(static_cast<float>(value))
{}
private:
uint16_t _data;
};
// Use complete implementation if necessary.
#if defined HALF_HALF_HPP
using half_t = half;
#else
using half_t = half_impl;
#endif
} // namespace cldnn

110
src/plugins/intel_gpu/include/intel_gpu/runtime/layout.hpp
View File

@ -5,7 +5,6 @@
#pragma once
#include "tensor.hpp"
#include "half.hpp"
#include <cmath>
#include <cstdlib>
@ -34,41 +33,14 @@ constexpr size_t uint_type_mask = 0x40;
constexpr size_t bin_type_mask = 0x20;
/// @brief Possible data types could be stored in memory.
enum class data_types : size_t {
bin = sizeof(int32_t) | bin_type_mask,
u8 = sizeof(uint8_t) | uint_type_mask,
i8 = sizeof(int8_t),
f16 = sizeof(int16_t) | float_type_mask,
f32 = sizeof(float) | float_type_mask,
i32 = sizeof(int32_t),
i64 = sizeof(int64_t)
};
/// Converts C++ type to @ref data_types .
template <typename T>
struct type_to_data_type;
#ifndef DOXYGEN_SHOULD_SKIP_THIS
template <>
struct type_to_data_type<int8_t> { static constexpr data_types value = data_types::i8; };
template <>
struct type_to_data_type<uint8_t> { static constexpr data_types value = data_types::u8; };
template <>
struct type_to_data_type<int32_t> { static constexpr data_types value = data_types::i32; };
template <>
struct type_to_data_type<int64_t> { static constexpr data_types value = data_types::i64; };
template <>
struct type_to_data_type<half_t> { static constexpr data_types value = data_types::f16; };
template <>
struct type_to_data_type<float> { static constexpr data_types value = data_types::f32; };
#endif
using data_types = ov::element::Type_t;
/// Converts @ref data_types to C++ type.
template <data_types Data_Type>
struct data_type_to_type;
#ifndef DOXYGEN_SHOULD_SKIP_THIS
template <>
struct data_type_to_type<data_types::bin> { typedef uint32_t type; };
struct data_type_to_type<data_types::u1> { typedef uint32_t type; };
template <>
struct data_type_to_type<data_types::u8> { typedef uint8_t type; };
template <>
@ -78,7 +50,7 @@ struct data_type_to_type<data_types::i32> { typedef int32_t type; };
template <>
struct data_type_to_type<data_types::i64> { typedef int64_t type; };
template <>
struct data_type_to_type<data_types::f16> { typedef half_t type; };
struct data_type_to_type<data_types::f16> { typedef ov::float16 type; };
template <>
struct data_type_to_type<data_types::f32> { typedef float type; };
#endif
@ -86,21 +58,24 @@ struct data_type_to_type<data_types::f32> { typedef float type; };
/// Helper class to identify key properties for data_types.
struct data_type_traits {
static size_t size_of(data_types data_type) {
return (static_cast<uint32_t>(data_type) & ~(float_type_mask | uint_type_mask | bin_type_mask));
auto et = ov::element::Type(data_type);
OPENVINO_ASSERT(et.bitwidth() >= 8, "[GPU] Unexpected data_type_traits::size_of call for type with bitwidth < 8 (", et.get_type_name(), ")");
return et.size();
}
static bool is_floating_point(data_types data_type) {
return (static_cast<uint32_t>(data_type) & float_type_mask) != 0;
return ov::element::Type(data_type).is_real();
}
static bool is_i8_u8(data_types data_type) {
return data_type == data_types::i8 || data_type == data_types::u8;
auto et = ov::element::Type(data_type);
return et.is_quantized() && et.bitwidth() == 8;
}
static size_t align_of(data_types data_type) {
switch (data_type) {
case data_types::bin:
return alignof(data_type_to_type<data_types::bin>::type);
case data_types::u1:
return alignof(data_type_to_type<data_types::u1>::type);
case data_types::i8:
return alignof(data_type_to_type<data_types::i8>::type);
case data_types::u8:
@ -119,32 +94,14 @@ struct data_type_traits {
}
static std::string name(data_types data_type) {
switch (data_type) {
case data_types::bin:
return "bin";
case data_types::i8:
return "i8";
case data_types::u8:
return "u8";
case data_types::i32:
return "i32";
case data_types::i64:
return "i64";
case data_types::f16:
return "f16";
case data_types::f32:
return "f32";
default:
assert(0);
return "unknown (" + std::to_string(typename std::underlying_type<data_types>::type(data_type)) + ")";
}
return ov::element::Type(data_type).get_type_name();
}
static data_types max_type(data_types dt1, data_types dt2) {
if (dt1 == data_types::bin)
if (dt1 == data_types::u1)
return dt2;
if (dt2 == data_types::bin)
if (dt2 == data_types::u1)
return dt1;
if (size_of(dt1) < size_of(dt2))
@ -160,7 +117,7 @@ struct data_type_traits {
}
static bool is_quantized(data_types dt) {
return dt == data_types::u8 || dt == data_types::i8;
return is_i8_u8(dt);
}
template <typename T>
@ -206,13 +163,7 @@ struct data_type_traits {
};
inline ::std::ostream& operator<<(::std::ostream& os, const data_types& dt) {
return os << data_type_traits::name(dt);
}
/// Helper function to check if C++ type matches @p data_type.
template <typename T>
bool data_type_match(data_types data_type) {
return data_type == type_to_data_type<T>::value;
return os << ov::element::Type(dt);
}
inline data_types element_type_to_data_type(ov::element::Type t) {
@ -237,33 +188,12 @@ inline data_types element_type_to_data_type(ov::element::Type t) {
case ov::element::Type_t::boolean:
return cldnn::data_types::u8;
case ov::element::Type_t::u1:
return cldnn::data_types::bin;
return cldnn::data_types::u1;
default:
throw std::runtime_error("Can't convert " + t.get_type_name() + " element type");
}
}
inline ov::element::Type data_type_to_element_type(data_types t) {
switch (t) {
case cldnn::data_types::f32:
return ov::element::Type_t::f32;
case cldnn::data_types::f16:
return ov::element::Type_t::f16;
case cldnn::data_types::u8:
return ov::element::Type_t::u8;
case cldnn::data_types::i8:
return ov::element::Type_t::i8;
case cldnn::data_types::i32:
return ov::element::Type_t::i32;
case cldnn::data_types::i64:
return ov::element::Type_t::i64;
case cldnn::data_types::bin:
return ov::element::Type_t::u1;
default:
throw std::runtime_error("Can't convert " + data_type_traits::name(t) + " precision");
}
}
/// Helper function to get both data_types and format::type in a single, unique value. Useable in 'case' statement.
constexpr auto fuse(data_types dt, cldnn::format::type fmt) -> decltype(static_cast<std::underlying_type<data_types>::type>(dt) |
static_cast<std::underlying_type<format::type>::type>(fmt)) {
@ -425,7 +355,7 @@ struct layout {
layout(const layout& other) = default;
layout()
: data_type(cldnn::data_types::bin)
: data_type(cldnn::data_types::undefined)
, format(cldnn::format::any)
, data_padding(padding())
, size(ov::PartialShape()) { }
@ -489,7 +419,7 @@ struct layout {
layout with_padding(padding const& padd) const;
/// Data type stored in @ref memory (see. @ref data_types)
data_types data_type;
ov::element::Type_t data_type;
/// Format stored in @ref memory (see. @ref format)
cldnn::format format;
@ -498,7 +428,7 @@ struct layout {
padding data_padding;
/// Number of bytes needed to store this layout
size_t bytes_count() const { return data_type_traits::size_of(data_type) * get_linear_size(); }
size_t bytes_count() const { return (ov::element::Type(data_type).bitwidth() * get_linear_size() + 7) >> 3; }
size_t get_rank() const;

8
src/plugins/intel_gpu/include/intel_gpu/runtime/memory.hpp
View File

@ -61,7 +61,7 @@ struct memory {
return true;
}
if (_bytes_count == (l.data_type == data_types::bin ? ceil_div(l.count(), 32) : l.count()) * data_type_traits::size_of(l.data_type)) {
if (_bytes_count == l.bytes_count()) {
return false;
}
@ -186,7 +186,7 @@ template<typename T>
inline std::vector<T> read_vector(cldnn::memory::ptr mem, const cldnn::stream& stream) {
cldnn::data_types mem_dtype = mem->get_layout().data_type;
if (mem_dtype == data_types::f16 || mem_dtype == data_types::f32) {
if (!std::is_floating_point<T>::value && !std::is_same<T, half_t>::value) {
if (!std::is_floating_point<T>::value && !std::is_same<T, ov::float16>::value) {
OPENVINO_ASSERT(false, "[GPU] read_vector: attempt to convert floating point memory to non-floating point memory");
}
}
@ -211,7 +211,7 @@ inline std::vector<T> read_vector(cldnn::memory::ptr mem, const cldnn::stream& s
case data_types::f16: {
auto p_mem = reinterpret_cast<uint16_t*>(mem->buffer_ptr());
for (size_t i = 0; i < mem->count(); ++i) {
out_vecs.push_back(static_cast<T>(half_to_float(p_mem[i])));
out_vecs.push_back(static_cast<T>(ov::float16::from_bits(p_mem[i])));
}
break;
}
@ -237,7 +237,7 @@ inline std::vector<T> read_vector(cldnn::memory::ptr mem, const cldnn::stream& s
break;
}
case data_types::f16: {
mem_lock<half_t, mem_lock_type::read> lock{mem, stream};
mem_lock<ov::float16, mem_lock_type::read> lock{mem, stream};
out_vecs = std::move(std::vector<T>(lock.begin(), lock.end()));
break;
}

4
src/plugins/intel_gpu/include/intel_gpu/runtime/tensor_accessor.hpp
View File

@ -13,9 +13,7 @@
namespace cldnn {
inline ov::Tensor make_tensor(const layout& l, void* memory_pointer) {
ov::element::Type et = data_type_to_element_type(l.data_type);
return ov::Tensor(et, l.get_shape(), memory_pointer);
return ov::Tensor(l.data_type, l.get_shape(), memory_pointer);
}
struct TensorsContainer final {

2
src/plugins/intel_gpu/src/graph/CMakeLists.txt
View File

@ -62,7 +62,7 @@ ov_install_static_lib(${TARGET_NAME} ${OV_CPACK_COMP_CORE})
if(ENABLE_SSE42)
ie_sse42_optimization_flags(sse4_2_flags)
set_source_files_properties(impls/cpu/detection_output.cpp half.cpp PROPERTIES
set_source_files_properties(impls/cpu/detection_output.cpp PROPERTIES
COMPILE_FLAGS "${sse4_2_flags}"
COMPILE_DEFINITIONS "HAVE_SSE")
endif()

4
src/plugins/intel_gpu/src/graph/condition.cpp
View File

@ -85,7 +85,7 @@ bool condition_inst::get_pred_from_memory(memory::ptr mem, stream& stream) {
case cldnn::data_types::f32:
return convert_data<float>(mem, stream);
case cldnn::data_types::f16:
return convert_data<half_t>(mem, stream);
return convert_data<ov::float16>(mem, stream);
case cldnn::data_types::i64:
return convert_data<int64_t>(mem, stream);
case cldnn::data_types::i32:
@ -94,7 +94,7 @@ bool condition_inst::get_pred_from_memory(memory::ptr mem, stream& stream) {
return convert_data<int8_t>(mem, stream);
case cldnn::data_types::u8:
return convert_data<uint8_t>(mem, stream);
case cldnn::data_types::bin:
case cldnn::data_types::u1:
default:
return convert_data<uint32_t>(mem, stream);
}

8
src/plugins/intel_gpu/src/graph/error_handler.cpp
View File

@ -81,8 +81,8 @@ void error_on_mismatching_data_types(const std::string& file,
(data_format_1 == data_types::u8 && data_format_2 == data_types::i8))) {
std::stringstream error_msg;
error_msg << "Data formats are incompatible." << std::endl;
error_msg << data_format_1_id << " format is: " << data_type_traits::name(data_format_1) << ", "
<< data_format_2_id << " is: " << data_type_traits::name(data_format_2) << std::endl;
error_msg << data_format_1_id << " format is: " << ov::element::Type(data_format_1) << ", "
<< data_format_2_id << " is: " << ov::element::Type(data_format_2) << std::endl;
error_msg << "Data formats should be the same!" << std::endl;
err_details::cldnn_print_error_message(file, line, instance_id, error_msg, additional_message);
}
@ -217,8 +217,8 @@ void error_on_mismatch_layout(const std::string& file,
}
if (layout_1.data_type != layout_2.data_type) {
error_msg << layout_1_id << " data type mismatch: " << layout_2_id << " data type." << std::endl;
error_msg << layout_1_id << " data type: " << data_type_traits::name(layout_1.data_type) << ", "
<< layout_2_id << " data type: " << data_type_traits::name(layout_2.data_type) << std::endl;
error_msg << layout_1_id << " data type: " << ov::element::Type(layout_1.data_type) << ", "
<< layout_2_id << " data type: " << ov::element::Type(layout_2.data_type) << std::endl;
}
if (layout_1.format != layout_2.format) {
error_msg << layout_1_id << " format mismatch: " << layout_2_id << " format." << std::endl;

4
src/plugins/intel_gpu/src/graph/graph_optimizer/add_required_reorders.cpp
View File

@ -272,10 +272,10 @@ void add_required_reorders::run(program& p) {
OPENVINO_ASSERT(correct_layout_selected,
"[GPU] No layout format available for ", usr->id(), ", impl_type: ", usr->get_preferred_impl_type(),
" (format: ", original_layout.format.to_string(),
", data_type: ", data_type_traits::name(original_layout.data_type), ") ",
", data_type: ", ov::element::Type(original_layout.data_type), ") ",
"compatible with ", node.first->id(),
" (format: ", node.first->get_output_layout().format.to_string(),
", data_type: ", data_type_traits::name(node.first->get_output_layout().data_type), ")");
", data_type: ", ov::element::Type(node.first->get_output_layout().data_type), ")");
}
}

8
src/plugins/intel_gpu/src/graph/graph_optimizer/pre_replace_deconv.cpp
View File

@ -217,7 +217,7 @@ void pre_replace_deconv::run(program& p) {
std::vector<float> weights_vec_float;
if (weights_data_type == data_types::f16) {
mem_lock<half_t, mem_lock_type::read> src{ weights_node_ptr->as<data>().get_attached_memory_ptr(), stream };
mem_lock<ov::float16, mem_lock_type::read> src{ weights_node_ptr->as<data>().get_attached_memory_ptr(), stream };
for (uint32_t i = 0; i < weights_layout.count(); i++)
weights_vec_float.push_back(static_cast<float>(src.data()[i]));
} else {
@ -236,8 +236,8 @@ void pre_replace_deconv::run(program& p) {
subpixel_weights);
if (weights_data_type == data_types::f16) {
mem_lock<half_t, mem_lock_type::write> dst{ data_to_allocate, stream};
program_helpers::set_weights_values<half_t>(dst.data(), subpixel_weights);
mem_lock<ov::float16, mem_lock_type::write> dst{ data_to_allocate, stream};
program_helpers::set_weights_values<ov::float16>(dst.data(), subpixel_weights);
} else if (weights_data_type == data_types::f32) {
mem_lock<float, mem_lock_type::write> dst{ data_to_allocate, stream };
program_helpers::set_weights_values<float>(dst.data(), subpixel_weights);
@ -282,7 +282,7 @@ void pre_replace_deconv::run(program& p) {
float bias = 0;
if (bias_data_type == data_types::f16) {
mem_lock<half_t, mem_lock_type::read> src{ bias_id_node_ptr->as<data>().get_attached_memory_ptr(), stream };
mem_lock<ov::float16, mem_lock_type::read> src{ bias_id_node_ptr->as<data>().get_attached_memory_ptr(), stream };
bias = static_cast<float>(src.data()[0]);
} else {
mem_lock<float, mem_lock_type::read> src{ bias_id_node_ptr->as<data>().get_attached_memory_ptr(), stream };

15
src/plugins/intel_gpu/src/graph/graph_optimizer/prepare_primitive_fusing.cpp
View File

@ -354,14 +354,13 @@ void prepare_primitive_fusing::fuse_bias(program &p) {
}
case data_types::f16: {
cldnn::memory_ptr new_mem = p.get_engine().allocate_memory(original_mem->get_layout());
mem_lock<uint16_t, mem_lock_type::write> new_bias_mem(new_mem, p.get_stream());
mem_lock<uint16_t, mem_lock_type::read> original_bias_mem(original_mem, p.get_stream());
mem_lock<uint16_t, mem_lock_type::read> second_bias_mem(second_mem, p.get_stream());
uint16_t* original_data = original_bias_mem.data();
uint16_t* new_data = second_bias_mem.data();
mem_lock<ov::float16, mem_lock_type::write> new_bias_mem(new_mem, p.get_stream());
mem_lock<ov::float16, mem_lock_type::read> original_bias_mem(original_mem, p.get_stream());
mem_lock<ov::float16, mem_lock_type::read> second_bias_mem(second_mem, p.get_stream());
ov::float16* original_data = original_bias_mem.data();
ov::float16* new_data = second_bias_mem.data();
for (size_t i = 0; i < original_bias_mem.size(); i++) {
float new_val = half_to_float(original_data[i]) + half_to_float(new_data[i]);
new_bias_mem[i] = float_to_half(new_val);
new_bias_mem[i] = original_data[i] + new_data[i];
}
original_node.attach_memory(new_mem);
@ -853,7 +852,7 @@ void prepare_primitive_fusing::fuse_simple_primitives(program &p) {
auto& input_lo = quantize_node.get_dependency(1);
auto& input_hi = quantize_node.get_dependency(2);
bool should_fuse = input_data.is_type<binary_convolution>() &&
((out_dt == data_types::bin &&
((out_dt == data_types::u1 &&
quantize_node.get_dependencies().size() == 5 &&
((in_layout.feature() == input_lo.get_output_layout().feature() &&
in_layout.feature() == input_hi.get_output_layout().feature()) ||

16
src/plugins/intel_gpu/src/graph/graph_optimizer/prepare_quantization.cpp
View File

@ -96,7 +96,7 @@ void prepare_quantization::prepare_scale_shift_opt(program &p, quantize_node& qu
auto lock_memory = [&stream] (memory::ptr memory, std::function<void(std::size_t, float)>& set_data,
std::function<float(size_t)>& get_data) {
using float_mem_lock = mem_lock<float, mem_lock_type::write>;
using uint16_t_mem_lock = mem_lock<uint16_t, mem_lock_type::write>;
using float16_mem_lock = mem_lock<ov::float16, mem_lock_type::write>;
switch (memory->get_layout().data_type) {
case data_types::f32: {
std::shared_ptr<float_mem_lock> data_lock_ptr = std::make_shared<float_mem_lock>(memory, stream);
@ -107,18 +107,18 @@ void prepare_quantization::prepare_scale_shift_opt(program &p, quantize_node& qu
get_data = [data] (size_t idx) {
return data[idx];
};
return std::pair<std::shared_ptr<float_mem_lock>, std::shared_ptr<uint16_t_mem_lock>>(data_lock_ptr, nullptr);
return std::pair<std::shared_ptr<float_mem_lock>, std::shared_ptr<float16_mem_lock>>(data_lock_ptr, nullptr);
}
case data_types::f16: {
std::shared_ptr<uint16_t_mem_lock> data_lock_ptr = std::make_shared<uint16_t_mem_lock>(memory, stream);
uint16_t* data = data_lock_ptr->data();
std::shared_ptr<float16_mem_lock> data_lock_ptr = std::make_shared<float16_mem_lock>(memory, stream);
ov::float16* data = data_lock_ptr->data();
set_data = [data] (size_t idx, float value) {
data[idx] = float_to_half(value);
data[idx] = ov::float16(value);
};
get_data = [data] (size_t idx) {
return half_to_float(data[idx]);
return static_cast<float>(data[idx]);
};
return std::pair<std::shared_ptr<float_mem_lock>, std::shared_ptr<uint16_t_mem_lock>>(nullptr, data_lock_ptr);
return std::pair<std::shared_ptr<float_mem_lock>, std::shared_ptr<float16_mem_lock>>(nullptr, data_lock_ptr);
}
default:
throw std::runtime_error("prepare_quantization: Unsupported precision of quantize output values");
@ -358,7 +358,7 @@ void prepare_quantization::prepare_packed_quantize(program& p, quantize_node& qu
auto output_dt = quantize_node.get_output_layout().data_type;
if (is_binarization) {
output_dt = data_types::bin;
output_dt = data_types::u1;
}
quantize_node.typed_desc()->output_data_types = {optional_data_type{output_dt}};

4
src/plugins/intel_gpu/src/graph/graph_optimizer/reorder_inputs.cpp
View File

@ -755,7 +755,7 @@ void reorder_inputs::run(program& p, layout_optimizer& lo, reorder_factory& rf)
auto& input = binary_conv_node.input();
auto input_layout = input.get_output_layout();
auto new_layout = input_layout;
new_layout.data_type = data_types::bin;
new_layout.data_type = data_types::u1;
auto reorder = rf.get_reorder(input.id(), input_layout, new_layout);
@ -766,7 +766,7 @@ void reorder_inputs::run(program& p, layout_optimizer& lo, reorder_factory& rf)
auto& weights = binary_conv_node.weights();
auto weights_layout = weights.get_output_layout();
if (!weights.is_type<data>() && !weights.is_constant()) {
auto new_layout = layout{ weights_layout.get_partial_shape(), data_types::bin, format::b_fs_yx_32fp };
auto new_layout = layout{ weights_layout.get_partial_shape(), data_types::u1, format::b_fs_yx_32fp };
auto reorder = rf.get_reorder(weights.id(), weights_layout, new_layout);
if (reorder.first) {
p.add_intermediate(reorder.first, binary_conv_node, 1, !reorder.second);

165
src/plugins/intel_gpu/src/graph/half.cpp
View File

@ -1,165 +0,0 @@
// Copyright (C) 2018-2023 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include <stdint.h>
#ifdef HAVE_SSE
#include <immintrin.h>
#else
#include "openvino/core/type/float16.hpp"
#endif // HAVE_SSE
#include "intel_gpu/runtime/half.hpp"
namespace cldnn {
#ifdef HAVE_SSE
float half_to_float(uint16_t value) {
static const uint32_t FLOAT16_EXP_SHIFT = (23 - 10);
static const uint32_t FLOAT16_EXP_MASK = 0x7C00;
static const uint32_t FLOAT32_EXP_MASK = 0x7F800000;
static const uint32_t FLOAT16_MANTISSA_MASK = 0x03FF;
static const uint32_t FLOAT16_TO_32_BIAS_DIFF_DENORM =
((127 - 15 - 10)
<< 23); // The difference is (127-15) but we want to do the calculation in the exp place (bit 23:32)
static const uint32_t FLOAT16_TO_32_BIAS_DIFF = ((127 - 15) << 10);
static const uint32_t FLOAT16_IMPLICIT_1 = (1 << 10);
static const uint32_t FLOAT16_EXP_MIN = (1 << 10);
static const uint32_t FLOAT16_SIGN_MASK = 0x8000;
__m128i a = _mm_unpacklo_epi16(_mm_set1_epi16(value), _mm_setzero_si128());
__m128i exps = _mm_and_si128(_mm_set1_epi32(FLOAT16_EXP_MASK), a); // Mask the exponents
__m128i mantissa = _mm_and_si128(_mm_set1_epi32(FLOAT16_MANTISSA_MASK), a); // Mask the mantissa
__m128i signs = _mm_and_si128(_mm_set1_epi32(FLOAT16_SIGN_MASK), a);
signs = _mm_slli_epi32(signs, 16);
__m128i nans = _mm_cmpeq_epi32(exps, _mm_set1_epi32(FLOAT16_EXP_MASK));
nans = _mm_and_si128(nans, _mm_set1_epi32(FLOAT32_EXP_MASK));
nans = _mm_or_si128(nans, signs);
__m128i subnormals = _mm_cmpeq_epi32(exps, _mm_setzero_si128());
int out32;
// e\m| 0 | 1
// ------------
// 0 | 0 | S
// ------------
// 1 | N | N
//
// The expression: (~exp) & mantissa, will evaluate to 0 exactly when the number is non subnormal or it's zero (just
// like in the table) testz Tests for this condition
if (_mm_testz_si128(subnormals, mantissa)) {
__m128i tmp;
exps = _mm_add_epi32(exps, _mm_set1_epi32(FLOAT16_TO_32_BIAS_DIFF));
tmp = _mm_or_si128(exps, mantissa);
tmp = _mm_slli_epi32(tmp, FLOAT16_EXP_SHIFT);
tmp = _mm_blendv_epi8(
tmp,
_mm_setzero_si128(),
subnormals); // The idea is of course to use blendv_ps, but epi8 will work the same and won't switch stack
tmp = _mm_or_si128(tmp, nans);
out32 = _mm_extract_epi32(tmp, 0);
} else {
__m128i normals = _mm_andnot_si128(subnormals, _mm_set1_epi32(FLOAT16_IMPLICIT_1)); // Mark all normal numbers
mantissa = _mm_or_si128(mantissa, normals); // Apply implicit bit
exps = _mm_max_epi16(
exps,
_mm_set1_epi32(
FLOAT16_EXP_MIN)); // All subnormals will have 1 in the exponent (needed for correct bias computation)
exps = _mm_slli_epi32(exps, FLOAT16_EXP_SHIFT);
exps = _mm_add_epi32(exps, _mm_set1_epi32(FLOAT16_TO_32_BIAS_DIFF_DENORM));
__m128 tmp;
tmp = _mm_mul_ps(_mm_castsi128_ps(exps), _mm_cvtepi32_ps(mantissa));
tmp = _mm_or_ps(tmp, _mm_castsi128_ps(nans));
out32 = _mm_extract_ps(tmp, 0);
}
float outf32 = *reinterpret_cast<float*>(&out32);
return outf32;
}
uint16_t float_to_half(float value) {
#define TO_M128i(a) (*reinterpret_cast<__m128i*>(&(a)))
#define TO_M128(a) (*const_cast<__m128*>(reinterpret_cast<const __m128*>(&(a))))
static const uint32_t DWORD_SIGNMASK = 0x80000000;
static const uint32_t DWORD_MINFP16 = 0x38800000;
static const uint32_t DWORD_MAXFP16 = 0x477fe000;
static const uint32_t DWORD_FP16_2_POW_10 = (1 << 10);
static const uint32_t DWORD_FP16_EXPBIAS_NO_HALF = 0xc8000000;
static const uint32_t WORD_MAXFP16 = 0x7BFF;
static const __m128i IVec4SignMask = _mm_set1_epi32(DWORD_SIGNMASK);
static const __m128i IVec4MinNormalFp16 = _mm_set1_epi32(DWORD_MINFP16);
static const __m128i IVec4MaxNormalFp16 = _mm_set1_epi32(DWORD_MAXFP16);
static const __m128i IVec4OnePow10 = _mm_set1_epi32(DWORD_FP16_2_POW_10);
static const __m128i IVec4ExpBiasFp16 = _mm_set1_epi32(DWORD_FP16_EXPBIAS_NO_HALF);
static const __m128i IVec4MaxFp16InWords = _mm_set1_epi32(WORD_MAXFP16);
static const __m128 FVec4MaxNormalFp16 = TO_M128(IVec4MaxNormalFp16);
static const __m128 FVec4MinNormalFp16 = TO_M128(IVec4MinNormalFp16);
static const __m128i IVec4InfF32 = _mm_set1_epi32(0x7f800000); // inf in in hex representation
static const __m128i IVec4InfF16 = _mm_set1_epi32(0x00007c00);
static const __m128 FVec4MaxFp16InWords = TO_M128(IVec4MaxFp16InWords);
__m128 Src = _mm_set1_ps(value);
// Remove the sign bit from the source
__m128 AbsSrc = _mm_andnot_ps(TO_M128(IVec4SignMask), Src);
// Create a mask to identify the DWORDs that are smaller than the minimum normalized fp16 number
__m128 CmpToMinFp16Mask = _mm_cmplt_ps(AbsSrc, FVec4MinNormalFp16);
// Create a mask to identify the DWORDs that are larger than the maximum normalized fp16 number
__m128 CmpToMaxFp16Mask = _mm_cmpgt_ps(AbsSrc, FVec4MaxNormalFp16);
__m128i CmpToInfMask = _mm_cmpeq_epi32(TO_M128i(AbsSrc), IVec4InfF32);
// Create a mask with the minimum normalized fp16 number in the DWORDs that are smaller than it
__m128 MaskOfMinFp16 = _mm_and_ps(CmpToMinFp16Mask, FVec4MinNormalFp16);
__m128i MaskOf2POW10 = _mm_and_si128(TO_M128i(CmpToMinFp16Mask), IVec4OnePow10);
__m128 ResultPS = _mm_add_ps(AbsSrc, MaskOfMinFp16);
__m128i Result = TO_M128i(ResultPS);
// We need to move from a 127 biased domain to a 15 biased domain. This means subtracting 112 from the exponent. We
// will add '-112' to the exponent but since the exponent is shifted 23 bits to the left we need to shift '-112' 23
// bits to the left as well. This gives us 0xC8000000. We are going to shift the mantissa 13 bits to the right
// (moving from 23 bits mantissa to 10).
Result = _mm_add_epi32(Result, IVec4ExpBiasFp16);
// Shift the mantissa to go from 23 bits to 10 bits
Result = _mm_srli_epi32(Result, 13);
Result = _mm_sub_epi16(Result, MaskOf2POW10);
ResultPS = _mm_blendv_ps(TO_M128(Result), FVec4MaxFp16InWords, CmpToMaxFp16Mask);
Result = TO_M128i(ResultPS);
// infinity preserving blending
Result = _mm_blendv_epi8(Result, IVec4InfF16, CmpToInfMask);
__m128i iPackedResult = _mm_packs_epi32(Result, Result);
// iSignMask = mask of the sign bits of the source 4 dwords
__m128i iSignMask = _mm_and_si128(TO_M128i(Src), IVec4SignMask);
// Pack the sign mask to 4 words
__m128i iSignInWords = _mm_packs_epi32(iSignMask, iSignMask);
iPackedResult = _mm_or_si128(iPackedResult, iSignInWords);
return (uint16_t)_mm_extract_epi16(iPackedResult, 0);
}
#else
float half_to_float(uint16_t value) {
return ov::float16(value);
}
uint16_t float_to_half(float value) {
return ov::float16(value);
}
#endif // HAVE_SSE
} // namespace cldnn

2
src/plugins/intel_gpu/src/graph/impls/cpu/activation.cpp
View File

@ -110,7 +110,7 @@ struct activation_impl : public typed_primitive_impl<activation> {
// Most of the evaluate functions expect same data type for all inputs, so we need to convert params from float
typename data_type_to_type<DT>::type param_a = static_cast<typename data_type_to_type<DT>::type>(additional_params.a);
auto input_dt = data_type_to_element_type(instance.get_input_layout().data_type);
auto input_dt = instance.get_input_layout().data_type;
if (activation_function == activation_func::pow) {
input_host_tensors.push_back(ov::Tensor(input_dt, {}, &param_a));

4
src/plugins/intel_gpu/src/graph/impls/cpu/proposal.cpp
View File

@ -49,11 +49,11 @@ struct proposal_t {
inline float float_read_helper(const float* mem) { return *mem; }
inline float float_read_helper(const half_t* mem) { return static_cast<float>(*mem); }
inline float float_read_helper(const ov::float16* mem) { return static_cast<float>(*mem); }
inline void float_write_helper(float* mem, float f) { *mem = f; }
inline void float_write_helper(half_t* mem, float f) { *mem = static_cast<half_t>(f); }
inline void float_write_helper(ov::float16* mem, float f) { *mem = static_cast<ov::float16>(f); }
/****************************************************************************
* *

2
src/plugins/intel_gpu/src/graph/impls/cpu/range.cpp
View File

@ -66,7 +66,7 @@ struct range_impl : public typed_primitive_impl<range> {
const auto output_dt = params->get_output_layout().data_type;
op = std::make_shared<ov::op::v4::Range>();
op->set_output_type(data_type_to_element_type(output_dt));
op->set_output_type(output_dt);
}
OPENVINO_ASSERT(op->evaluate(output_host_tensors, input_host_tensors),

2
src/plugins/intel_gpu/src/graph/impls/cpu/tile.cpp
View File

@ -75,7 +75,7 @@ struct tile_impl : public typed_primitive_impl<tile> {
if (repeats.empty())
OPENVINO_THROW("[GPU] Unexpected configuration of tile impl");
auto repeats_tensor = ov::Tensor(data_type_to_element_type(data_types::i64), {repeats.size()}, repeats.data());
auto repeats_tensor = ov::Tensor(ov::element::i64, {repeats.size()}, repeats.data());
input_host_tensors.push_back(repeats_tensor);
}

2
src/plugins/intel_gpu/src/graph/impls/ocl/binary_convolution.cpp
View File

@ -77,7 +77,7 @@ namespace detail {
attach_binary_convolution_impl::attach_binary_convolution_impl() {
implementation_map<binary_convolution>::add(impl_types::ocl, typed_primitive_impl_ocl<binary_convolution>::create<binary_convolution_impl>, {
std::make_tuple(data_types::bin, format::b_fs_yx_32fp),
std::make_tuple(data_types::u1, format::b_fs_yx_32fp),
});
}

8
src/plugins/intel_gpu/src/graph/impls/ocl/kernel_selector_helper.cpp
View File

@ -121,7 +121,7 @@ namespace cldnn {
kernel_selector::data_type to_data_type(data_types dt) {
switch (dt) {
case cldnn::data_types::bin:
case cldnn::data_types::u1:
return kernel_selector::data_type::BINARY;
case cldnn::data_types::i8:
return kernel_selector::data_type::INT8;
@ -143,7 +143,7 @@ kernel_selector::data_type to_data_type(data_types dt) {
data_types from_data_type(kernel_selector::data_type dt) {
switch (dt) {
case kernel_selector::data_type::BINARY:
return cldnn::data_types::bin;
return cldnn::data_types::u1;
case kernel_selector::data_type::INT8:
return cldnn::data_types::i8;
case kernel_selector::data_type::UINT8:
@ -163,7 +163,7 @@ data_types from_data_type(kernel_selector::data_type dt) {
kernel_selector::weights_type to_weights_type(data_types dt) {
switch (dt) {
case cldnn::data_types::bin:
case cldnn::data_types::u1:
return kernel_selector::weights_type::BINARY;
case cldnn::data_types::i8:
return kernel_selector::weights_type::INT8;
@ -183,7 +183,7 @@ kernel_selector::weights_type to_weights_type(data_types dt) {
data_types from_weights_type(kernel_selector::weights_type dt) {
switch (dt) {
case kernel_selector::weights_type::BINARY:
return data_types::bin;
return data_types::u1;
case kernel_selector::weights_type::INT8:
return data_types::i8;
case kernel_selector::weights_type::UINT8:

15
src/plugins/intel_gpu/src/graph/impls/ocl/kernel_selector_helper.h
View File

@ -82,18 +82,21 @@ using params = kernel_selector::Params;
using weights_reorder_params = kernel_selector::WeightsReorderParams;
} // namespace kernel_selector
namespace ov {
namespace element {
enum class Type_t;
} // namespaec element
} // namespaec ov
namespace cldnn {
enum class data_types : size_t;
struct format;
struct layout;
struct program;
struct fused_primitive_desc;
kernel_selector::data_type to_data_type(data_types dt);
data_types from_data_type(kernel_selector::data_type dt);
kernel_selector::weights_type to_weights_type(data_types dt);
data_types from_weights_type(kernel_selector::weights_type dt);
kernel_selector::data_type to_data_type(ov::element::Type_t dt);
ov::element::Type_t from_data_type(kernel_selector::data_type dt);
kernel_selector::weights_type to_weights_type(ov::element::Type_t dt);
ov::element::Type_t from_weights_type(kernel_selector::weights_type dt);
kernel_selector::data_layout to_data_layout(format f);
cldnn::format from_data_layout(kernel_selector::data_layout l);
kernel_selector::weights_layout to_weights_layout(format f, bool is_grouped);

4
src/plugins/intel_gpu/src/graph/impls/ocl/non_max_suppression.cpp
View File

@ -162,8 +162,8 @@ private:
auto& stream = node.get_program().get_stream();
switch (mem->get_layout().data_type) {
case data_types::f16: {
mem_lock<half_t, mem_lock_type::read> lock(mem, stream);
auto mem_value = static_cast<half_t*>(lock.data());
mem_lock<ov::float16, mem_lock_type::read> lock(mem, stream);
auto mem_value = static_cast<ov::float16*>(lock.data());
retValue = static_cast<T>(*mem_value);
} break;
case data_types::f32: {

2
src/plugins/intel_gpu/src/graph/impls/ocl/quantize.cpp
View File

@ -91,7 +91,7 @@ public:
void update_dispatch_data(const kernel_impl_params& impl_param) override {
auto quantize_params = get_default_params<kernel_selector::quantize_params>(impl_param);
const auto& output_layout = impl_param.get_output_layout();
quantize_params.packed_binary_output = output_layout.data_type == data_types::bin;
quantize_params.packed_binary_output = output_layout.data_type == data_types::u1;
(_kernel_data.update_dispatch_data_func)(quantize_params, _kernel_data);
}
};

4
src/plugins/intel_gpu/src/graph/include/loop_inst.h
View File

@ -89,7 +89,7 @@ public:
break;
}
default:
throw std::runtime_error("Invalid data type : " + data_type_traits::name(prim_layout.data_type));
throw std::runtime_error("Invalid data type : " + ov::element::Type(prim_layout.data_type).get_type_name());
}
return trip_count;
}
@ -129,7 +129,7 @@ public:
break;
}
default:
throw std::runtime_error("Invalid data type : " + data_type_traits::name(prim_layout.data_type));
throw std::runtime_error("Invalid data type : " + ov::element::Type(prim_layout.data_type).get_type_name());
}
}

2
src/plugins/intel_gpu/src/graph/include/memory_accessor.hpp
View File

@ -59,7 +59,7 @@ struct MemoryAccessor : public ov::ITensorAccessor {
const auto t_iter = m_ptrs->find(port);
if (t_iter != m_ptrs->cend()) {
m_accessed_data = t_iter->second;
return {data_type_to_element_type(m_accessed_data->get_layout().data_type),
return {m_accessed_data->get_layout().data_type,
m_accessed_data->get_layout().get_shape(),
m_accessed_data->lock(m_stream, mem_lock_type::read)};
} else if (m_clbk) {

2
src/plugins/intel_gpu/src/graph/include/quantize_inst.h
View File

@ -142,7 +142,7 @@ public:
program_node& input(size_t index = 0) const { return get_dependency(index); }
int get_levels() const { return get_primitive()->levels; }
bool get_packed_binary_output() const { return get_output_layout().data_type == data_types::bin; }
bool get_packed_binary_output() const { return get_output_layout().data_type == data_types::u1; }
bool get_scale_shift_opt() const { return get_primitive()->scale_shift_opt; }
bool get_need_pre_shift() const { return get_primitive()->need_pre_shift; }
bool get_need_post_scale() const { return get_primitive()->need_post_scale; }

2
src/plugins/intel_gpu/src/graph/include/to_string_utils.h
View File

@ -24,7 +24,7 @@ namespace cldnn {
inline std::string bool_to_str(bool cond) { return cond ? "true" : "false"; }
inline std::string dt_to_str(data_types dt) {
return data_type_traits::name(dt);
return ov::element::Type(dt).to_string();
}
inline std::string fmt_to_str(format fmt) {

9
src/plugins/intel_gpu/src/graph/network.cpp
View File

@ -14,7 +14,6 @@
#include "intel_gpu/runtime/event.hpp"
#include "intel_gpu/runtime/stream.hpp"
#include "intel_gpu/runtime/debug_configuration.hpp"
#include "intel_gpu/runtime/half.hpp"
#include "intel_gpu/runtime/itt.hpp"
#include "intel_gpu/graph/program.hpp"
@ -140,7 +139,7 @@ float convert_element(int32_t i) { return static_cast<float>(i); }
float convert_element(float f) { return f; }
float convert_element(half_t h) { return half_to_float(h); }
float convert_element(ov::float16 h) { return static_cast<float>(h); }
size_t get_x_pitch(const layout& layout) {
try {
@ -266,8 +265,8 @@ void log_memory_to_file(memory::ptr mem, layout data_layout, stream& stream, std
if (mem_dt == cldnn::data_types::f32)
dump<float>(actual_mem, stream, file_stream, dump_raw);
else if (mem_dt == cldnn::data_types::f16)
dump<half_t>(actual_mem, stream, file_stream, dump_raw);
else if (mem_dt == cldnn::data_types::bin)
dump<ov::float16>(actual_mem, stream, file_stream, dump_raw);
else if (mem_dt == cldnn::data_types::u1)
dump<uint32_t>(actual_mem, stream, file_stream, dump_raw);
else if (mem_dt == cldnn::data_types::i64)
dump<int64_t>(actual_mem, stream, file_stream, dump_raw);
@ -311,7 +310,7 @@ static uint32_t get_unique_net_id() {
static std::string get_file_path_for_binary_dump(cldnn::layout layout, std::string name) {
std::string filename;
std::string data_type = data_type_traits::name(layout.data_type);
std::string data_type = ov::element::Type(layout.data_type).get_type_name();
std::string format = layout.format.to_string();
std::string tensor;
auto dims = layout.get_dims();

4
src/plugins/intel_gpu/src/graph/quantize.cpp
View File

@ -22,7 +22,7 @@ layout quantize_inst::calc_output_layout(quantize_node const& node, kernel_impl_
if (desc->output_data_types[0])
out_dt = *desc->output_data_types[0];
if (out_dt == data_types::bin) {
if (out_dt == data_types::u1) {
output_format = format::b_fs_yx_32fp;
}
@ -37,7 +37,7 @@ std::vector<layout> quantize_inst::calc_output_layouts(quantize_node const&, ker
auto output_format = input_layout.format;
auto out_dt = desc->output_data_types[0].value_or(input_layout.data_type);
if (out_dt == data_types::bin) {
if (out_dt == data_types::u1) {
output_format = format::b_fs_yx_32fp;
}

4
src/plugins/intel_gpu/src/graph/range.cpp
View File

@ -30,7 +30,7 @@ std::vector<layout> range_inst::calc_output_layouts(range_node const& /*node*/,
auto output_data_type = desc->output_data_types[0].value_or(impl_param.get_input_layout().data_type);
ov::op::v4::Range op;
op.set_output_type(data_type_to_element_type(output_data_type));
op.set_output_type(output_data_type);
std::vector<ShapeType> output_shapes = {ShapeType::dynamic(1)};
std::vector<ShapeType> input_shapes = {ov::Shape(), ov::Shape(), ov::Shape()};
@ -63,7 +63,7 @@ std::string range_inst::to_string(range_node const& node) {
auto node_info = node.desc_to_json();
json_composite op_info;
op_info.add("output_type", data_type_traits::name(desc->output_layout.data_type));
op_info.add("output_type", ov::element::Type(desc->output_layout.data_type));
node_info->add("range info", std::move(op_info));
return lexical_cast(*node_info);

2
src/plugins/intel_gpu/src/graph/tile.cpp
View File

@ -54,7 +54,7 @@ std::vector<layout> tile_inst::calc_output_layouts(tile_node const& /*node*/, co
auto repeats = desc->repeats;
const auto data_accessor =
MemoryAccessor(&impl_param.memory_deps, impl_param.prog->get_stream(), [&repeats, &repeats_shape](size_t port) {
return (port == 1 && repeats.data()) ? ov::Tensor(data_type_to_element_type(data_types::i64),
return (port == 1 && repeats.data()) ? ov::Tensor(ov::element::i64,
repeats_shape.to_shape(),
repeats.data())
: ov::Tensor();

2
src/plugins/intel_gpu/src/graph/topology.cpp
View File

@ -34,7 +34,7 @@ void topology::change_input_layout(const primitive_id& id, const layout& new_lay
throw std::invalid_argument("Unknown format of layout.");
if (new_layout.data_type != data_types::f16 && new_layout.data_type != data_types::f32 &&
new_layout.data_type != data_types::i8 && new_layout.data_type != data_types::bin &&
new_layout.data_type != data_types::i8 && new_layout.data_type != data_types::u1 &&
new_layout.data_type != data_types::u8 && new_layout.data_type != data_types::i32 &&
new_layout.data_type != data_types::i64)
throw std::invalid_argument("Unknown data_type of layout.");

6
src/plugins/intel_gpu/src/plugin/graph.cpp
View File

@ -281,7 +281,7 @@ std::shared_ptr<ov::Model> Graph::get_runtime_model(std::vector<cldnn::primitive
const auto& user_ids = prim_info.c_users;
size_t output_size = user_ids.size();
bool is_output = user_ids.empty();
auto out_et = cldnn::data_type_to_element_type(prim_info.output_layout.data_type);
auto out_et = prim_info.output_layout.data_type;
auto out_pshape = prim_info.output_layout.get_partial_shape();
std::shared_ptr<ov::Node> return_node;
@ -322,12 +322,12 @@ std::shared_ptr<ov::Model> Graph::get_runtime_model(std::vector<cldnn::primitive
results.back()->set_friendly_name(layerName + "_result");
std::map<std::string, std::string> info;
info[ov::exec_model_info::OUTPUT_PRECISIONS] = cldnn::data_type_to_element_type(prim_info.output_layout.data_type).get_type_name();
info[ov::exec_model_info::OUTPUT_PRECISIONS] = ov::element::Type(prim_info.output_layout.data_type).get_type_name();
info[ov::exec_model_info::LAYER_TYPE] = to_IE_type_name(prim_info.type_id);
info[ov::exec_model_info::OUTPUT_LAYOUTS] = prim_info.layout_str;
info[ov::exec_model_info::EXECUTION_ORDER] = std::to_string(prim_info.exec_id);
info[ov::exec_model_info::IMPL_TYPE] = prim_info.kernel_id;
info[ov::exec_model_info::RUNTIME_PRECISION] = cldnn::data_type_to_element_type(prim_info.runtime_precision).get_type_name();
info[ov::exec_model_info::RUNTIME_PRECISION] = ov::element::Type(prim_info.runtime_precision).get_type_name();
std::vector<std::string> originalNames{find_origin_layers(prim_info.original_id)};
for (auto& fused_id : prim_info.c_fused_ids) {

4
src/plugins/intel_gpu/src/plugin/sync_infer_request.cpp
View File

@ -107,7 +107,7 @@ bool is_convert_required(ov::element::Type src_et, ov::element::Type dst_et) {
}
void convert_and_copy(const cldnn::memory::ptr src, ov::ITensor const* dst, const cldnn::stream& stream) {
auto src_et = cldnn::data_type_to_element_type(src->get_layout().data_type);
auto src_et = src->get_layout().data_type;
auto dst_et = dst->get_element_type();
size_t size = ov::shape_size(dst->get_shape());
@ -558,7 +558,7 @@ cldnn::event::ptr SyncInferRequest::copy_output_data(cldnn::memory::ptr src, con
const auto& layout = src->get_layout();
auto& stream = m_graph->get_network()->get_stream();
if (is_convert_required(cldnn::data_type_to_element_type(layout.data_type), dst.get_element_type())) {
if (is_convert_required(layout.data_type, dst.get_element_type())) {
convert_and_copy(src, &dst, stream);
return nullptr;
} else {

3
src/plugins/intel_gpu/src/plugin/variable_state.cpp
View File

@ -18,9 +18,8 @@ VariableState::VariableState(const std::string &name, cldnn::network::VariableSt
, m_engine(engine) {
auto internal_memory = m_variable_state->memory;
auto internal_layout = internal_memory->get_layout();
auto et = cldnn::data_type_to_element_type(internal_layout.data_type);
auto shape = internal_layout.get_shape();
m_state = ov::make_tensor(et, shape);
m_state = ov::make_tensor(internal_layout.data_type, shape);
}
void VariableState::reset() {

18
src/plugins/intel_gpu/src/runtime/layout.cpp
View File

@ -30,18 +30,6 @@ std::vector<int32_t> convert_dimensions(const std::vector<int32_t>& sizes, std::
} // namespace
// The definitions below are needed to follow ODR
// Otherwise statements like
// optional_value ov = type_to_data_type<float>::value;
// optional_value ov(type_to_data_type<float>::value);
// violate ODR and leads to undefined behavior
const data_types type_to_data_type<int8_t>::value;
const data_types type_to_data_type<uint8_t>::value;
const data_types type_to_data_type<int32_t>::value;
const data_types type_to_data_type<int64_t>::value;
const data_types type_to_data_type<half_t>::value;
const data_types type_to_data_type<float>::value;
size_t layout::get_rank() const {
return format.dimension();
}
@ -189,7 +177,7 @@ std::vector<size_t> layout::get_dims_order() const {
std::string layout::to_string() const {
std::stringstream s;
s << "\n{\n"
<< "\tdata_type=" << data_type_traits::name(data_type) << ";\n"
<< "\tdata_type=" << ov::element::Type(data_type) << ";\n"
<< "\tformat=" << format.to_string() << ";\n"
<< "\tshape=" << size << ";\n"
<< "\tpad_l=" << data_padding.lower_size().to_string() << ";\n"
@ -213,7 +201,7 @@ std::string layout::to_short_string() const {
}
};
s << data_type_traits::name(data_type) << ":" << format.to_string() << ":";
s << ov::element::Type(data_type) << ":" << format.to_string() << ":";
dump_shape(s, size);
if (data_padding.get_dynamic_pad_dims() != tensor(0)) {
@ -421,7 +409,7 @@ size_t layout::get_linear_size() const {
static_cast<size_t>(1),
std::multiplies<size_t>());
return (this->data_type == data_types::bin) ? ceil_div(total, 32) : total;
return total;
}
layout layout::with_padding(padding const& padd) const {

2
src/plugins/intel_gpu/tests/unit/dynamic_execution/is_valid_fusion_test.cpp
View File

@ -23,7 +23,7 @@ TEST(eltwise_activation_fusing_test, basic_dynamic_rank4) {
layout weight_layout = layout{ov::PartialShape{1, 3, 3, 3}, data_types::f16, format::bfyx};
auto weights = engine.allocate_memory(weight_layout);
set_values<FLOAT16>(weights, {
set_values<ov::float16>(weights, {
1.0f, 1.0f, 1.0f,
1.0f, 1.0f, 1.0f,
1.0f, 1.0f, 1.0f,

4
src/plugins/intel_gpu/tests/unit/dynamic_execution/memory_realloc_test.cpp
View File

@ -27,7 +27,7 @@ TEST(memory_reuse_realloc_reset_test, basic_conv_with_padding) {
layout weight_layout = layout{ov::PartialShape{1, 3, 3, 3}, data_types::f16, format::bfyx};
auto weights = engine.allocate_memory(weight_layout);
set_values<FLOAT16>(weights, {
set_values<ov::float16>(weights, {
1.0f, 1.0f, 1.0f,
1.0f, 1.0f, 1.0f,
1.0f, 1.0f, 1.0f,
@ -115,7 +115,7 @@ TEST(memory_reuse_realloc_reset_test, basic_conv_with_padding) {
// 0, 0,"0","0","0","0", // !! check pad_after
// 0, 0,"0","0","0","0", // !! check pad_after
auto reorder_mem = network.get_primitive("reorder")->output_memory_ptr();
cldnn::mem_lock<FLOAT16, mem_lock_type::read> reorder_mem_ptr(reorder_mem, get_test_stream());
cldnn::mem_lock<ov::float16, mem_lock_type::read> reorder_mem_ptr(reorder_mem, get_test_stream());
for (size_t i = 26; i < 29; ++i) {
ASSERT_EQ((float)reorder_mem_ptr[i], 0.f);
}

12
src/plugins/intel_gpu/tests/unit/dynamic_execution/optimized_out_execution_test.cpp
View File

@ -38,25 +38,25 @@ TEST(optimized_out_execution_test, concat_blocked_format) {
auto input3 = engine.allocate_memory(input3_layout);
auto input4 = engine.allocate_memory(input4_layout);
set_values<FLOAT16>(input1, {
set_values<ov::float16>(input1, {
1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f,
10.0f, 20.0f, 30.0f, 40.0f, 50.0f, 60.0f, 70.0f, 80.0f,
1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f,
10.0f, 20.0f, 30.0f, 40.0f, 50.0f, 60.0f, 70.0f, 80.0f
});
set_values<FLOAT16>(input2, {
set_values<ov::float16>(input2, {
1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f,
10.0f, 20.0f, 30.0f, 40.0f, 50.0f, 60.0f, 70.0f, 80.0f,
1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f,
10.0f, 20.0f, 30.0f, 40.0f, 50.0f, 60.0f, 70.0f, 80.0f
});
set_values<FLOAT16>(input3, {
set_values<ov::float16>(input3, {
1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f,
10.0f, 20.0f, 30.0f, 40.0f, 50.0f, 60.0f, 70.0f, 80.0f,
1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f,
10.0f, 20.0f, 30.0f, 40.0f, 50.0f, 60.0f, 70.0f, 80.0f
});
set_values<FLOAT16>(input4, {
set_values<ov::float16>(input4, {
1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f,
10.0f, 20.0f, 30.0f, 40.0f, 50.0f, 60.0f, 70.0f, 80.0f,
1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f,
@ -83,7 +83,7 @@ TEST(optimized_out_execution_test, concat_blocked_format) {
network.set_input_data("input3", input3);
network.set_input_data("input4", input4);
std::vector<FLOAT16> ref = {
std::vector<ov::float16> ref = {
2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f,
20.0f, 40.0f, 60.0f, 80.0f, 100.0f, 120.0f, 140.0f, 160.0f,
2.0f, 4.0f, 6.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f,
@ -104,7 +104,7 @@ TEST(optimized_out_execution_test, concat_blocked_format) {
auto outputs = network.execute();
auto output_mem = outputs.begin()->second.get_memory();
cldnn::mem_lock<FLOAT16> output_mem_ptr(output_mem, get_test_stream());
cldnn::mem_lock<ov::float16> output_mem_ptr(output_mem, get_test_stream());
for (size_t i = 0; i < output_mem->get_layout().get_buffer_size().count(); ++i) {
ASSERT_EQ(output_mem_ptr[i], ref[i]);

4
src/plugins/intel_gpu/tests/unit/float16.natvis
View File

@ -1,7 +1,7 @@
<?xml version="1.0" encoding="utf-8"?>
<AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">
<Type Name="FLOAT16">
<Type Name="ov::float16">
<DisplayString Condition = "format.exponent == 0 &amp;&amp; format.significand == 0 &amp;&amp; format.sign == 0">+0</DisplayString>
<DisplayString Condition = "format.exponent == 0 &amp;&amp; format.significand == 0 &amp;&amp; format.sign == 1">-0</DisplayString>
<DisplayString Condition = "format.exponent == 31 &amp;&amp; format.significand == 0 &amp;&amp; format.sign == 0">+infinity</DisplayString>
@ -12,4 +12,4 @@
<DisplayString Condition = "format.exponent &gt;= 15">{ (1 &lt;&lt; (format.exponent-15)) * (-2*format.sign+1.0f) * (1.0f + format.significand/1024.0f) }</DisplayString>
</Type>
</AutoVisualizer>
</AutoVisualizer>

10
src/plugins/intel_gpu/tests/unit/fusions/binary_convolution_fusion_test.cpp
View File

@ -71,9 +71,9 @@ public:
} // namespace
#define CASE_BIN_CONV1 { 1, 16, 4, 5 }, { 1, 16, 4, 5 }, { 1, 1, 3, 3 }, { 1, 1 }, { 1, 1 }, { 1, 1 }, 1, data_types::bin, format::b_fs_yx_32fp, data_types::bin, format::os_is_yx_osv32_isv32p, data_types::f32, format::bfyx
#define CASE_BIN_CONV2 { 1, 16, 4, 5 }, { 1, 30, 4, 5 }, { 1, 1, 1, 1 }, { 1, 1 }, { 0, 0 }, { 1, 1 }, 1, data_types::bin, format::b_fs_yx_32fp, data_types::bin, format::os_is_yx_osv32_isv32p, data_types::f32, format::bfyx
#define CASE_BIN_CONV3 { 1, 184, 12, 21 }, { 1, 224, 12, 21 }, { 1, 1, 1, 1 }, { 1, 1 }, { 0, 0 }, { 1, 1 }, 1, data_types::bin, format::b_fs_yx_32fp, data_types::bin, format::os_is_yx_osv32_isv32p, data_types::f32, format::bfyx
#define CASE_BIN_CONV1 { 1, 16, 4, 5 }, { 1, 16, 4, 5 }, { 1, 1, 3, 3 }, { 1, 1 }, { 1, 1 }, { 1, 1 }, 1, data_types::u1, format::b_fs_yx_32fp, data_types::u1, format::os_is_yx_osv32_isv32p, data_types::f32, format::bfyx
#define CASE_BIN_CONV2 { 1, 16, 4, 5 }, { 1, 30, 4, 5 }, { 1, 1, 1, 1 }, { 1, 1 }, { 0, 0 }, { 1, 1 }, 1, data_types::u1, format::b_fs_yx_32fp, data_types::u1, format::os_is_yx_osv32_isv32p, data_types::f32, format::bfyx
#define CASE_BIN_CONV3 { 1, 184, 12, 21 }, { 1, 224, 12, 21 }, { 1, 1, 1, 1 }, { 1, 1 }, { 0, 0 }, { 1, 1 }, 1, data_types::u1, format::b_fs_yx_32fp, data_types::u1, format::os_is_yx_osv32_isv32p, data_types::f32, format::bfyx
/* ----------------------------------------------------------------------------------------------------- */
/* -------------------------------------- binary convolution cases ------------------------------------- */
@ -133,7 +133,7 @@ TEST_P(conv_bin_quantize_bin, channel_wise_quantize) {
data("out_hi", get_mem(get_per_channel_layout(p), 1)),
binary_convolution("bin_conv_prim", input_info("input"), { "weights" }, p.stride, p.pad, p.dilation, p.out_shape, p.groups),
quantize("quantize_data", input_info("bin_conv_prim"), input_info("in_lo"), input_info("in_hi"),
input_info("out_lo"), input_info("out_hi"), 2, data_types::bin),
input_info("out_lo"), input_info("out_hi"), 2, data_types::u1),
reorder("reorder_bfyx", input_info("quantize_data"), p.default_format, data_types::f32)
);
@ -153,7 +153,7 @@ TEST_P(conv_bin_quantize_bin, blob_wise_quantize) {
data("out_hi", get_mem(get_single_element_layout(p), 1)),
binary_convolution("bin_conv_prim", input_info("input"), { "weights" }, p.stride, p.pad, p.dilation, p.out_shape, p.groups),
quantize("quantize_data", input_info("bin_conv_prim"), input_info("in_lo"), input_info("in_hi"),
input_info("out_lo"), input_info("out_hi"), 2, data_types::bin),
input_info("out_lo"), input_info("out_hi"), 2, data_types::u1),
reorder("reorder_bfyx", input_info("quantize_data"), p.default_format, data_types::f32)
);

14
src/plugins/intel_gpu/tests/unit/fusions/fusion_test_common.hpp
View File

@ -114,7 +114,7 @@ public:
cldnn::memory::ptr get_mem(cldnn::layout l) {
auto prim = engine.allocate_memory(l);
tensor s = l.get_tensor();
if (l.data_type == data_types::bin) {
if (l.data_type == data_types::u1) {
VF<int32_t> rnd_vec = rg.generate_random_1d<int32_t>(s.count() / 32, min_random, max_random);
set_values(prim, rnd_vec);
} else if (l.data_type == data_types::i8 || l.data_type == data_types::u8) {
@ -134,11 +134,11 @@ public:
cldnn::memory::ptr get_mem(cldnn::layout l, float fill_value) {
auto prim = engine.allocate_memory(l);
tensor s = l.get_tensor();
if (l.data_type == data_types::bin) {
if (l.data_type == data_types::u1) {
VF<int32_t> rnd_vec(s.count() / 32, static_cast<int32_t>(fill_value));
set_values(prim, rnd_vec);
} else if (l.data_type == data_types::f16) {
VF<uint16_t> rnd_vec(s.count(), float_to_half(fill_value));
VF<uint16_t> rnd_vec(s.count(), ov::float16(fill_value).to_bits());
set_values(prim, rnd_vec);
} else if (l.data_type == data_types::f32) {
VF<float> rnd_vec(s.count(), fill_value);
@ -163,13 +163,13 @@ public:
VF<float> rnd_vec = rg.generate_random_norepetitions<float>(s.count(), min, max);
set_values(prim, rnd_vec);
} else if (l.data_type == data_types::f16) {
VF<FLOAT16> rnd_vec = rg.generate_random_norepetitions<FLOAT16>(s.count(), min, max);
VF<ov::float16> rnd_vec = rg.generate_random_norepetitions<ov::float16>(s.count(), min, max);
set_values(prim, rnd_vec);
} else if (l.data_type == data_types::i8) {
VF<int8_t> rnd_vec = rg.generate_random_norepetitions<int8_t>(s.count(), min, max);
set_values(prim, rnd_vec);
}
else if (l.data_type == data_types::bin) {
else if (l.data_type == data_types::u1) {
VF<int32_t> rnd_vec = rg.generate_random_norepetitions<int32_t>(s.count(), min, max);
set_values(prim, rnd_vec);
}
@ -184,7 +184,7 @@ public:
VF<float> rnd_vec = rg.generate_random_1d<float>(s.count(), min, max);
set_values(prim, rnd_vec);
} else if (l.data_type == data_types::f16) {
VF<FLOAT16> rnd_vec = rg.generate_random_1d<FLOAT16>(s.count(), min, max);
VF<ov::float16> rnd_vec = rg.generate_random_1d<ov::float16>(s.count(), min, max);
set_values(prim, rnd_vec);
} else if (l.data_type == data_types::i8) {
VF<int8_t> rnd_vec = rg.generate_random_1d<int8_t>(s.count(), min, max);
@ -192,7 +192,7 @@ public:
} else if (l.data_type == data_types::u8) {
VF<uint8_t> rnd_vec = rg.generate_random_1d<uint8_t>(s.count(), min, max);
set_values(prim, rnd_vec);
} else if (l.data_type == data_types::bin) {
} else if (l.data_type == data_types::u1) {
VF<int32_t> rnd_vec = rg.generate_random_1d<int32_t>(s.count() / 32, min, max);
set_values(prim, rnd_vec);
}

2
src/plugins/intel_gpu/tests/unit/fusions/scatter_nd_update_fusion_test.cpp
View File

@ -104,7 +104,7 @@ public:
VF<float> rnd_vec = generate_unique_indices<float>(p);
set_values(prim, rnd_vec);
} else if (indices_layout.data_type == data_types::f16) {
VF<FLOAT16> rnd_vec = generate_unique_indices<FLOAT16>(p);
VF<ov::float16> rnd_vec = generate_unique_indices<ov::float16>(p);
set_values(prim, rnd_vec);
} else if (indices_layout.data_type == data_types::i8) {
VF<int8_t> rnd_vec = generate_unique_indices<int8_t>(p);

4
src/plugins/intel_gpu/tests/unit/module_tests/graph_manipulation_gpu_test.cpp
View File

@ -36,8 +36,8 @@ TEST(basic, test1) {
auto weights1 = engine.allocate_memory({ data_types::f16, format::yxfb,{ 1, 1, 2, 1 } });
auto weights2 = engine.allocate_memory({ data_types::f32, format::byxf,{ 1, 1, 1, 2 } });
set_values(input, { FLOAT16(1.1f), FLOAT16(1.2f), FLOAT16(1.3f), FLOAT16(1.4f) });
set_values(weights1, { FLOAT16(2.1f), FLOAT16(3.1f) });
set_values(input, { ov::float16(1.1f), ov::float16(1.2f), ov::float16(1.3f), ov::float16(1.4f) });
set_values(weights1, { ov::float16(2.1f), ov::float16(3.1f) });
set_values(weights2, { 1.1f, 0.1f });
topology topology;

4
src/plugins/intel_gpu/tests/unit/module_tests/optionals_test.cpp
View File

@ -32,9 +32,9 @@ TEST(optional_data_types, basic) {
ASSERT_EQ(o2.value(), cldnn::data_types::f32);
}
optional_data_type o3(type_to_data_type<FLOAT16>::value);
optional_data_type o3(cldnn::data_types::f16);
ASSERT_EQ(o3.value(), cldnn::data_types::f16);
optional_data_type o4(type_to_data_type<float>::value);
optional_data_type o4(cldnn::data_types::f32);
ASSERT_EQ(o4.value(), cldnn::data_types::f32);
}

8
src/plugins/intel_gpu/tests/unit/passes/handle_reshape.cpp
View File

@ -229,11 +229,11 @@ TEST(handle_reshape, reshape_input_reorder) {
auto in1_layout = layout{ ov::PartialShape{-1, 16, 64, 64}, data_types::f16, format::bfyx };
auto in1_memory = engine.allocate_memory({ ov::PartialShape{2, 16, 64, 64}, data_types::f16, format::bfyx });
auto in0 = rg.generate_random_1d<FLOAT16>(in0_memory->count(), -10, 10);
auto in1 = rg.generate_random_1d<FLOAT16>(in1_memory->count(), -10, 10);
set_values<FLOAT16>(in0_memory, in0);
auto in0 = rg.generate_random_1d<ov::float16>(in0_memory->count(), -10, 10);
auto in1 = rg.generate_random_1d<ov::float16>(in1_memory->count(), -10, 10);
set_values<ov::float16>(in0_memory, in0);
set_values<int32_t>(shape_memory, {1, 2, 16, 64, 64});
set_values<FLOAT16>(in1_memory, in1);
set_values<ov::float16>(in1_memory, in1);
topology topology;
topology.add(input_layout("input0", in0_layout));

88
src/plugins/intel_gpu/tests/unit/passes/prepare_buffer_fusing_test.cpp
View File

@ -383,37 +383,37 @@ TEST(prepare_buffer_fusing, in_place_concat_dynamic_onednn_batch1) {
auto input_memory1 = engine.allocate_memory(in_layout1);
auto input_memory2 = engine.allocate_memory(in_layout2);
set_values<FLOAT16>(input_memory1,
{FLOAT16(1.0f), FLOAT16(2.0f), FLOAT16(3.0f), FLOAT16(4.0f), FLOAT16(5.0f), FLOAT16(6.0f), FLOAT16(7.0f), FLOAT16(8.0f),
FLOAT16(11.0f), FLOAT16(22.0f), FLOAT16(33.0f), FLOAT16(44.0f), FLOAT16(55.0f), FLOAT16(66.0f), FLOAT16(77.0f), FLOAT16(88.0f),
FLOAT16(1.0f), FLOAT16(2.0f), FLOAT16(3.0f), FLOAT16(4.0f), FLOAT16(5.0f), FLOAT16(6.0f), FLOAT16(7.0f), FLOAT16(8.0f),
FLOAT16(11.0f), FLOAT16(22.0f), FLOAT16(33.0f), FLOAT16(44.0f), FLOAT16(55.0f), FLOAT16(66.0f), FLOAT16(77.0f), FLOAT16(88.0f)});
set_values<FLOAT16>(input_memory2,
{FLOAT16(111.0f), FLOAT16(222.0f), FLOAT16(333.0f), FLOAT16(444.0f), FLOAT16(555.0f), FLOAT16(666.0f), FLOAT16(777.0f), FLOAT16(888.0f),
FLOAT16(1111.0f), FLOAT16(2222.0f), FLOAT16(3333.0f), FLOAT16(4444.0f), FLOAT16(5555.0f), FLOAT16(6666.0f), FLOAT16(7777.0f), FLOAT16(8888.0f),
FLOAT16(111.0f), FLOAT16(222.0f), FLOAT16(333.0f), FLOAT16(444.0f), FLOAT16(555.0f), FLOAT16(666.0f), FLOAT16(777.0f), FLOAT16(888.0f),
FLOAT16(1111.0f), FLOAT16(2222.0f), FLOAT16(3333.0f), FLOAT16(4444.0f), FLOAT16(5555.0f), FLOAT16(6666.0f), FLOAT16(7777.0f), FLOAT16(8888.0f)});
set_values<ov::float16>(input_memory1,
{ov::float16(1.0f), ov::float16(2.0f), ov::float16(3.0f), ov::float16(4.0f), ov::float16(5.0f), ov::float16(6.0f), ov::float16(7.0f), ov::float16(8.0f),
ov::float16(11.0f), ov::float16(22.0f), ov::float16(33.0f), ov::float16(44.0f), ov::float16(55.0f), ov::float16(66.0f), ov::float16(77.0f), ov::float16(88.0f),
ov::float16(1.0f), ov::float16(2.0f), ov::float16(3.0f), ov::float16(4.0f), ov::float16(5.0f), ov::float16(6.0f), ov::float16(7.0f), ov::float16(8.0f),
ov::float16(11.0f), ov::float16(22.0f), ov::float16(33.0f), ov::float16(44.0f), ov::float16(55.0f), ov::float16(66.0f), ov::float16(77.0f), ov::float16(88.0f)});
set_values<ov::float16>(input_memory2,
{ov::float16(111.0f), ov::float16(222.0f), ov::float16(333.0f), ov::float16(444.0f), ov::float16(555.0f), ov::float16(666.0f), ov::float16(777.0f), ov::float16(888.0f),
ov::float16(1111.0f), ov::float16(2222.0f), ov::float16(3333.0f), ov::float16(4444.0f), ov::float16(5555.0f), ov::float16(6666.0f), ov::float16(7777.0f), ov::float16(8888.0f),
ov::float16(111.0f), ov::float16(222.0f), ov::float16(333.0f), ov::float16(444.0f), ov::float16(555.0f), ov::float16(666.0f), ov::float16(777.0f), ov::float16(888.0f),
ov::float16(1111.0f), ov::float16(2222.0f), ov::float16(3333.0f), ov::float16(4444.0f), ov::float16(5555.0f), ov::float16(6666.0f), ov::float16(7777.0f), ov::float16(8888.0f)});
net.set_input_data("input1", input_memory1);
net.set_input_data("input2", input_memory2);
std::vector<FLOAT16> ref_output = {
FLOAT16(1.0f), FLOAT16(2.0f), FLOAT16(3.0f), FLOAT16(4.0f), FLOAT16(5.0f), FLOAT16(6.0f), FLOAT16(7.0f), FLOAT16(8.0f),
FLOAT16(11.0f), FLOAT16(22.0f), FLOAT16(33.0f), FLOAT16(44.0f), FLOAT16(55.0f), FLOAT16(66.0f), FLOAT16(77.0f), FLOAT16(88.0f),
FLOAT16(111.0f), FLOAT16(222.0f), FLOAT16(333.0f), FLOAT16(444.0f), FLOAT16(555.0f), FLOAT16(666.0f), FLOAT16(777.0f), FLOAT16(888.0f),
FLOAT16(1111.0f), FLOAT16(2222.0f), FLOAT16(3333.0f), FLOAT16(4444.0f), FLOAT16(5555.0f), FLOAT16(6666.0f), FLOAT16(7777.0f), FLOAT16(8888.0f),
FLOAT16(1.0f), FLOAT16(2.0f), FLOAT16(3.0f), FLOAT16(4.0f), FLOAT16(5.0f), FLOAT16(6.0f), FLOAT16(7.0f), FLOAT16(8.0f),
FLOAT16(11.0f), FLOAT16(22.0f), FLOAT16(33.0f), FLOAT16(44.0f), FLOAT16(55.0f), FLOAT16(66.0f), FLOAT16(77.0f), FLOAT16(88.0f),
FLOAT16(111.0f), FLOAT16(222.0f), FLOAT16(333.0f), FLOAT16(444.0f), FLOAT16(555.0f), FLOAT16(666.0f), FLOAT16(777.0f), FLOAT16(888.0f),
FLOAT16(1111.0f), FLOAT16(2222.0f), FLOAT16(3333.0f), FLOAT16(4444.0f), FLOAT16(5555.0f), FLOAT16(6666.0f), FLOAT16(7777.0f), FLOAT16(8888.0f)};
std::vector<ov::float16> ref_output = {
ov::float16(1.0f), ov::float16(2.0f), ov::float16(3.0f), ov::float16(4.0f), ov::float16(5.0f), ov::float16(6.0f), ov::float16(7.0f), ov::float16(8.0f),
ov::float16(11.0f), ov::float16(22.0f), ov::float16(33.0f), ov::float16(44.0f), ov::float16(55.0f), ov::float16(66.0f), ov::float16(77.0f), ov::float16(88.0f),
ov::float16(111.0f), ov::float16(222.0f), ov::float16(333.0f), ov::float16(444.0f), ov::float16(555.0f), ov::float16(666.0f), ov::float16(777.0f), ov::float16(888.0f),
ov::float16(1111.0f), ov::float16(2222.0f), ov::float16(3333.0f), ov::float16(4444.0f), ov::float16(5555.0f), ov::float16(6666.0f), ov::float16(7777.0f), ov::float16(8888.0f),
ov::float16(1.0f), ov::float16(2.0f), ov::float16(3.0f), ov::float16(4.0f), ov::float16(5.0f), ov::float16(6.0f), ov::float16(7.0f), ov::float16(8.0f),
ov::float16(11.0f), ov::float16(22.0f), ov::float16(33.0f), ov::float16(44.0f), ov::float16(55.0f), ov::float16(66.0f), ov::float16(77.0f), ov::float16(88.0f),
ov::float16(111.0f), ov::float16(222.0f), ov::float16(333.0f), ov::float16(444.0f), ov::float16(555.0f), ov::float16(666.0f), ov::float16(777.0f), ov::float16(888.0f),
ov::float16(1111.0f), ov::float16(2222.0f), ov::float16(3333.0f), ov::float16(4444.0f), ov::float16(5555.0f), ov::float16(6666.0f), ov::float16(7777.0f), ov::float16(8888.0f)};
std::map<cldnn::primitive_id, cldnn::network_output> output;
EXPECT_NO_THROW(output = net.execute());
auto out_l = net.get_output_layout("output");
auto out_mem = output.at("output").get_memory();
cldnn::mem_lock<FLOAT16> output_ptr(out_mem, get_test_stream());
cldnn::mem_lock<ov::float16> output_ptr(out_mem, get_test_stream());
cldnn::mem_lock<FLOAT16> input1_ptr(input_memory1, get_test_stream());
cldnn::mem_lock<FLOAT16> input2_ptr(input_memory2, get_test_stream());
cldnn::mem_lock<ov::float16> input1_ptr(input_memory1, get_test_stream());
cldnn::mem_lock<ov::float16> input2_ptr(input_memory2, get_test_stream());
const auto& concat_inst = net.get_primitive("concat");
const auto& concat_node_n = concat_inst->get_node();
@ -461,37 +461,37 @@ TEST(prepare_buffer_fusing, in_place_concat_dynamic_onednn_batch2) {
auto input_memory1 = engine.allocate_memory(in_layout1);
auto input_memory2 = engine.allocate_memory(in_layout2);
set_values<FLOAT16>(input_memory1,
{FLOAT16(1.0f), FLOAT16(2.0f), FLOAT16(3.0f), FLOAT16(4.0f), FLOAT16(5.0f), FLOAT16(6.0f), FLOAT16(7.0f), FLOAT16(8.0f),
FLOAT16(11.0f), FLOAT16(22.0f), FLOAT16(33.0f), FLOAT16(44.0f), FLOAT16(55.0f), FLOAT16(66.0f), FLOAT16(77.0f), FLOAT16(88.0f),
FLOAT16(1.0f), FLOAT16(2.0f), FLOAT16(3.0f), FLOAT16(4.0f), FLOAT16(5.0f), FLOAT16(6.0f), FLOAT16(7.0f), FLOAT16(8.0f),
FLOAT16(11.0f), FLOAT16(22.0f), FLOAT16(33.0f), FLOAT16(44.0f), FLOAT16(55.0f), FLOAT16(66.0f), FLOAT16(77.0f), FLOAT16(88.0f)});
set_values<FLOAT16>(input_memory2,
{FLOAT16(111.0f), FLOAT16(222.0f), FLOAT16(333.0f), FLOAT16(444.0f), FLOAT16(555.0f), FLOAT16(666.0f), FLOAT16(777.0f), FLOAT16(888.0f),
FLOAT16(1111.0f), FLOAT16(2222.0f), FLOAT16(3333.0f), FLOAT16(4444.0f), FLOAT16(5555.0f), FLOAT16(6666.0f), FLOAT16(7777.0f), FLOAT16(8888.0f),
FLOAT16(111.0f), FLOAT16(222.0f), FLOAT16(333.0f), FLOAT16(444.0f), FLOAT16(555.0f), FLOAT16(666.0f), FLOAT16(777.0f), FLOAT16(888.0f),
FLOAT16(1111.0f), FLOAT16(2222.0f), FLOAT16(3333.0f), FLOAT16(4444.0f), FLOAT16(5555.0f), FLOAT16(6666.0f), FLOAT16(7777.0f), FLOAT16(8888.0f)});
set_values<ov::float16>(input_memory1,
{ov::float16(1.0f), ov::float16(2.0f), ov::float16(3.0f), ov::float16(4.0f), ov::float16(5.0f), ov::float16(6.0f), ov::float16(7.0f), ov::float16(8.0f),
ov::float16(11.0f), ov::float16(22.0f), ov::float16(33.0f), ov::float16(44.0f), ov::float16(55.0f), ov::float16(66.0f), ov::float16(77.0f), ov::float16(88.0f),
ov::float16(1.0f), ov::float16(2.0f), ov::float16(3.0f), ov::float16(4.0f), ov::float16(5.0f), ov::float16(6.0f), ov::float16(7.0f), ov::float16(8.0f),
ov::float16(11.0f), ov::float16(22.0f), ov::float16(33.0f), ov::float16(44.0f), ov::float16(55.0f), ov::float16(66.0f), ov::float16(77.0f), ov::float16(88.0f)});
set_values<ov::float16>(input_memory2,
{ov::float16(111.0f), ov::float16(222.0f), ov::float16(333.0f), ov::float16(444.0f), ov::float16(555.0f), ov::float16(666.0f), ov::float16(777.0f), ov::float16(888.0f),
ov::float16(1111.0f), ov::float16(2222.0f), ov::float16(3333.0f), ov::float16(4444.0f), ov::float16(5555.0f), ov::float16(6666.0f), ov::float16(7777.0f), ov::float16(8888.0f),
ov::float16(111.0f), ov::float16(222.0f), ov::float16(333.0f), ov::float16(444.0f), ov::float16(555.0f), ov::float16(666.0f), ov::float16(777.0f), ov::float16(888.0f),
ov::float16(1111.0f), ov::float16(2222.0f), ov::float16(3333.0f), ov::float16(4444.0f), ov::float16(5555.0f), ov::float16(6666.0f), ov::float16(7777.0f), ov::float16(8888.0f)});
net.set_input_data("input1", input_memory1);
net.set_input_data("input2", input_memory2);
std::vector<FLOAT16> ref_output = {
FLOAT16(1.0f), FLOAT16(2.0f), FLOAT16(3.0f), FLOAT16(4.0f), FLOAT16(5.0f), FLOAT16(6.0f), FLOAT16(7.0f), FLOAT16(8.0f),
FLOAT16(11.0f), FLOAT16(22.0f), FLOAT16(33.0f), FLOAT16(44.0f), FLOAT16(55.0f), FLOAT16(66.0f), FLOAT16(77.0f), FLOAT16(88.0f),
FLOAT16(1.0f), FLOAT16(2.0f), FLOAT16(3.0f), FLOAT16(4.0f), FLOAT16(5.0f), FLOAT16(6.0f), FLOAT16(7.0f), FLOAT16(8.0f),
FLOAT16(11.0f), FLOAT16(22.0f), FLOAT16(33.0f), FLOAT16(44.0f), FLOAT16(55.0f), FLOAT16(66.0f), FLOAT16(77.0f), FLOAT16(88.0f),
FLOAT16(111.0f), FLOAT16(222.0f), FLOAT16(333.0f), FLOAT16(444.0f), FLOAT16(555.0f), FLOAT16(666.0f), FLOAT16(777.0f), FLOAT16(888.0f),
FLOAT16(1111.0f), FLOAT16(2222.0f), FLOAT16(3333.0f), FLOAT16(4444.0f), FLOAT16(5555.0f), FLOAT16(6666.0f), FLOAT16(7777.0f), FLOAT16(8888.0f),
FLOAT16(111.0f), FLOAT16(222.0f), FLOAT16(333.0f), FLOAT16(444.0f), FLOAT16(555.0f), FLOAT16(666.0f), FLOAT16(777.0f), FLOAT16(888.0f),
FLOAT16(1111.0f), FLOAT16(2222.0f), FLOAT16(3333.0f), FLOAT16(4444.0f), FLOAT16(5555.0f), FLOAT16(6666.0f), FLOAT16(7777.0f), FLOAT16(8888.0f)};
std::vector<ov::float16> ref_output = {
ov::float16(1.0f), ov::float16(2.0f), ov::float16(3.0f), ov::float16(4.0f), ov::float16(5.0f), ov::float16(6.0f), ov::float16(7.0f), ov::float16(8.0f),
ov::float16(11.0f), ov::float16(22.0f), ov::float16(33.0f), ov::float16(44.0f), ov::float16(55.0f), ov::float16(66.0f), ov::float16(77.0f), ov::float16(88.0f),
ov::float16(1.0f), ov::float16(2.0f), ov::float16(3.0f), ov::float16(4.0f), ov::float16(5.0f), ov::float16(6.0f), ov::float16(7.0f), ov::float16(8.0f),
ov::float16(11.0f), ov::float16(22.0f), ov::float16(33.0f), ov::float16(44.0f), ov::float16(55.0f), ov::float16(66.0f), ov::float16(77.0f), ov::float16(88.0f),
ov::float16(111.0f), ov::float16(222.0f), ov::float16(333.0f), ov::float16(444.0f), ov::float16(555.0f), ov::float16(666.0f), ov::float16(777.0f), ov::float16(888.0f),
ov::float16(1111.0f), ov::float16(2222.0f), ov::float16(3333.0f), ov::float16(4444.0f), ov::float16(5555.0f), ov::float16(6666.0f), ov::float16(7777.0f), ov::float16(8888.0f),
ov::float16(111.0f), ov::float16(222.0f), ov::float16(333.0f), ov::float16(444.0f), ov::float16(555.0f), ov::float16(666.0f), ov::float16(777.0f), ov::float16(888.0f),
ov::float16(1111.0f), ov::float16(2222.0f), ov::float16(3333.0f), ov::float16(4444.0f), ov::float16(5555.0f), ov::float16(6666.0f), ov::float16(7777.0f), ov::float16(8888.0f)};
std::map<cldnn::primitive_id, cldnn::network_output> output;
EXPECT_NO_THROW(output = net.execute());
auto out_l = net.get_output_layout("output");
auto out_mem = output.at("output").get_memory();
cldnn::mem_lock<FLOAT16> output_ptr(out_mem, get_test_stream());
cldnn::mem_lock<ov::float16> output_ptr(out_mem, get_test_stream());
cldnn::mem_lock<FLOAT16> input1_ptr(input_memory1, get_test_stream());
cldnn::mem_lock<FLOAT16> input2_ptr(input_memory2, get_test_stream());
cldnn::mem_lock<ov::float16> input1_ptr(input_memory1, get_test_stream());
cldnn::mem_lock<ov::float16> input2_ptr(input_memory2, get_test_stream());
const auto& concat_inst = net.get_primitive("concat");
const auto& concat_node_n = concat_inst->get_node();

2
src/plugins/intel_gpu/tests/unit/passes/prepare_padding_test.cpp
View File

@ -21,7 +21,7 @@ TEST(prepare_padding, groupconv_with_output) {
tests::random_generator rg(GET_SUITE_NAME);
auto& engine = get_test_engine();
auto in_layout = layout{{1, 18, 76, 135}, data_types::f16, format::bfyx};
auto weights_data = rg.generate_random_5d<FLOAT16>(1, 18, 1, 3, 3, -1, 1);
auto weights_data = rg.generate_random_5d<ov::float16>(1, 18, 1, 3, 3, -1, 1);
auto weights_mem = engine.allocate_memory({ {18, 1, 1, 3, 3}, data_types::f16, format::bfzyx});
set_values(weights_mem, weights_data);

14
src/plugins/intel_gpu/tests/unit/passes/prepare_primitive_fusing_test.cpp
View File

@ -466,7 +466,7 @@ TEST(prepare_primitive_fusing, eltwise_fusing_residual_connection) {
auto conv_in_layout = layout{ ov::PartialShape{1, 3, -1, -1}, data_types::f16, format::bfyx};
auto weight_layout = layout{ ov::PartialShape{10, 3, 3, 3}, data_types::f16, format::bfyx};
auto weight_mem = engine.allocate_memory(weight_layout);
auto weight_data = rg.generate_random_4d<FLOAT16>(10, 3, 3, 3, -1, 1);
auto weight_data = rg.generate_random_4d<ov::float16>(10, 3, 3, 3, -1, 1);
set_values(weight_mem, weight_data);
auto elt1_in1_layout = layout{ ov::PartialShape{1, 10, -1, -1}, data_types::f16, format::bfyx};
@ -493,11 +493,11 @@ TEST(prepare_primitive_fusing, eltwise_fusing_residual_connection) {
cldnn::network net(prog, 0);
// Valid
auto conv_input_data = rg.generate_random_4d<FLOAT16>(1, 3, 7, 7, -1, 1);
auto conv_input_data = rg.generate_random_4d<ov::float16>(1, 3, 7, 7, -1, 1);
auto conv_input_mem = engine.allocate_memory(layout{ov::PartialShape{1, 3, 7, 7}, data_types::f16, format::bfyx});
set_values(conv_input_mem, conv_input_data);
auto elt_input_data = rg.generate_random_4d<FLOAT16>(1, 10, 5, 5, -10, 10);
auto elt_input_data = rg.generate_random_4d<ov::float16>(1, 10, 5, 5, -10, 10);
auto elt_input_mem = engine.allocate_memory(layout{ov::PartialShape{1, 10, 5, 5}, data_types::f16, format::bfyx});
set_values(elt_input_mem, elt_input_data);
@ -509,7 +509,7 @@ TEST(prepare_primitive_fusing, eltwise_fusing_residual_connection) {
ASSERT_FALSE(conv_inst->has_unfused_subgraph());
// Invalid => unfusion
auto conv_input_data2 = rg.generate_random_4d<FLOAT16>(1, 3, 3, 3, -1, 1);
auto conv_input_data2 = rg.generate_random_4d<ov::float16>(1, 3, 3, 3, -1, 1);
auto conv_input_mem2 = engine.allocate_memory(layout{ov::PartialShape{1, 3, 3, 3}, data_types::f16, format::bfyx});
set_values(conv_input_mem2, conv_input_data2);
net.set_input_data("conv_input", conv_input_mem2);
@ -552,7 +552,7 @@ TEST(prepare_primitive_fusing, fuse_constant_transposes_accuracy_test) {
auto weights = engine.allocate_memory({{ 32, 2 }, data_types::f32, format::bfyx });
tests::random_generator rg(GET_SUITE_NAME);
auto input_data = rg.generate_random_2d<FLOAT16>(2, 32, -1, 1);
auto input_data = rg.generate_random_2d<ov::float16>(2, 32, -1, 1);
auto weights_data = rg.generate_random_2d<float>(32, 2, -1, 1);
set_values(input, flatten_2d(format::bfyx, input_data));
@ -576,7 +576,7 @@ TEST(prepare_primitive_fusing, fuse_constant_transposes_accuracy_test) {
auto outputs = network.execute();
auto output = outputs.at("fc").get_memory();
cldnn::mem_lock<FLOAT16> output_ptr(output, get_test_stream());
cldnn::mem_lock<ov::float16> output_ptr(output, get_test_stream());
ExecutionConfig config_ref = get_test_default_config(engine);
config_ref.set_property(ov::intel_gpu::optimize_data(false));
@ -587,7 +587,7 @@ TEST(prepare_primitive_fusing, fuse_constant_transposes_accuracy_test) {
auto outputs_ref = network_ref.execute();
auto output_ref = outputs_ref.at("fc").get_memory();
cldnn::mem_lock<FLOAT16> output_ptr_ref(output_ref, get_test_stream());
cldnn::mem_lock<ov::float16> output_ptr_ref(output_ref, get_test_stream());
for (size_t i = 0; i < output_ptr_ref.size(); ++i) {
ASSERT_EQ(output_ptr[i], output_ptr_ref[i]);

2
src/plugins/intel_gpu/tests/unit/shape_infer/quantize_si_test.cpp
View File

@ -74,7 +74,7 @@ INSTANTIATE_TEST_SUITE_P(smoke, quantize_test,
},
{
layout{ov::PartialShape{1, 2, 3, 4}, data_types::f32, format::bfyx},
layout{ov::PartialShape{1, 2, 3, 4}, data_types::bin, format::b_fs_yx_32fp}
layout{ov::PartialShape{1, 2, 3, 4}, data_types::u1, format::b_fs_yx_32fp}
},
{
layout{ov::PartialShape{1, 2, 3, 4, 5}, data_types::f32, format::bfzyx},

3
src/plugins/intel_gpu/tests/unit/shape_infer/random_uniform_si_test.cpp
View File

@ -64,7 +64,7 @@ TEST_P(random_uniform_si_test, shape_infer) {
auto allocated_mem = engine.allocate_memory(in_layout);
switch (p.out_data_type) {
case data_types::f16:
set_values(allocated_mem, {float_to_half(val)});
set_values(allocated_mem, {ov::float16(val).to_bits()});
break;
case data_types::f32:
set_values(allocated_mem, {static_cast<data_type_to_type<data_types::f32>::type>(val)});
@ -81,7 +81,6 @@ TEST_P(random_uniform_si_test, shape_infer) {
case data_types::u8:
set_values(allocated_mem, {static_cast<data_type_to_type<data_types::u8>::type>(val)});
break;
case data_types::bin:
default:
break;
}

5
src/plugins/intel_gpu/tests/unit/shape_infer/range_si_test.cpp
View File

@ -60,10 +60,10 @@ TEST_P(range_si_test, shape_infer) {
auto in_layout = input_layouts[idx];
if (in_layout.is_static() && (idx < p.vals.size())) {
auto prim_mem = engine.allocate_memory(in_layout);
ASSERT_NE(p.out_data_type, data_types::bin);
ASSERT_NE(p.out_data_type, data_types::undefined);
switch (p.out_data_type) {
case data_types::f16:
set_values(prim_mem, {float_to_half(p.vals[idx])});
set_values(prim_mem, {ov::float16(p.vals[idx]).to_bits()});
break;
case data_types::f32:
set_values(prim_mem, {static_cast<data_type_to_type<data_types::f32>::type>(p.vals[idx])});
@ -80,7 +80,6 @@ TEST_P(range_si_test, shape_infer) {
case data_types::u8:
set_values(prim_mem, {static_cast<data_type_to_type<data_types::u8>::type>(p.vals[idx])});
break;
case data_types::bin:
default:
break;
}

44
src/plugins/intel_gpu/tests/unit/test_cases/activation_simple_gpu_test.cpp
View File

@ -493,8 +493,8 @@ TEST(activation_f16_fw_gpu, softsign_basic_yxfb) {
auto& engine = get_test_engine();
auto input = engine.allocate_memory({data_types::f16, format::yxfb, {1, 1, 2, 2}});
set_values(input, {FLOAT16(1.0f), FLOAT16(2.0f), FLOAT16(3.0f), FLOAT16(4.5f)});
VF<FLOAT16> output_vec = {FLOAT16(0.5f), FLOAT16(0.66650391f), FLOAT16(0.75f), FLOAT16(0.81835938f)};
set_values(input, {ov::float16(1.0f), ov::float16(2.0f), ov::float16(3.0f), ov::float16(4.5f)});
VF<ov::float16> output_vec = {ov::float16(0.5f), ov::float16(0.66650391f), ov::float16(0.75f), ov::float16(0.81835938f)};
topology topology(input_layout("input", input->get_layout()),
activation("not", input_info("input"), activation_func::softsign));
@ -506,8 +506,8 @@ TEST(activation_f16_fw_gpu, softsign_basic_yxfb) {
auto output_memory = outputs.at("not").get_memory();
auto output_layout = output_memory->get_layout();
cldnn::mem_lock<FLOAT16> output_ptr(output_memory, get_test_stream());
cldnn::mem_lock<FLOAT16> input_ptr(input, get_test_stream());
cldnn::mem_lock<ov::float16> output_ptr(output_memory, get_test_stream());
cldnn::mem_lock<ov::float16> input_ptr(input, get_test_stream());
int y_size = output_layout.spatial(1);
int x_size = output_layout.spatial(0);
@ -611,12 +611,12 @@ TEST(activation_f16_fw_gpu, pow_basic_yxfb) {
auto input = engine.allocate_memory({ data_types::f16, format::yxfb, { 1, 1, 2, 2 } });
set_values(input,
{ FLOAT16(1.0f), FLOAT16(2.0f), FLOAT16(3.0f), FLOAT16(4.5f) });
VF<FLOAT16> output_vec = { FLOAT16(1.0f), FLOAT16(8.0f), FLOAT16(27.0f), FLOAT16(91.125f) };
{ ov::float16(1.0f), ov::float16(2.0f), ov::float16(3.0f), ov::float16(4.5f) });
VF<ov::float16> output_vec = { ov::float16(1.0f), ov::float16(8.0f), ov::float16(27.0f), ov::float16(91.125f) };
topology topology(
input_layout("input", input->get_layout()),
activation("pow", input_info("input"), activation_func::pow, { FLOAT16(3.0f), FLOAT16(0.0f) }));
activation("pow", input_info("input"), activation_func::pow, { ov::float16(3.0f), ov::float16(0.0f) }));
network network(engine, topology, get_test_default_config(engine));
network.set_input_data("input", input);
auto outputs = network.execute();
@ -625,7 +625,7 @@ TEST(activation_f16_fw_gpu, pow_basic_yxfb) {
auto output_memory = outputs.at("pow").get_memory();
auto output_layout = output_memory->get_layout();
cldnn::mem_lock<FLOAT16> output_ptr(output_memory, get_test_stream());
cldnn::mem_lock<ov::float16> output_ptr(output_memory, get_test_stream());
int y_size = output_layout.spatial(1);
int x_size = output_layout.spatial(0);
@ -971,8 +971,8 @@ TEST(activation_f16_fw_gpu, basic_bfyx_all_functions)
auto input = engine.allocate_memory({ data_types::f16, format::bfyx, { 1, 1, 2, 4 } });
auto input_params = engine.allocate_memory({ data_types::f16, format::bfyx, { 1, 2, 1, 1 } });
set_values(input, { FLOAT16(-4.5f), FLOAT16(-2.5f), FLOAT16(-1.5f), FLOAT16(0.5f),
FLOAT16(0.9f), FLOAT16(1.5f), FLOAT16(2.0f), FLOAT16(2.5f) });
set_values(input, { ov::float16(-4.5f), ov::float16(-2.5f), ov::float16(-1.5f), ov::float16(0.5f),
ov::float16(0.9f), ov::float16(1.5f), ov::float16(2.0f), ov::float16(2.5f) });
std::vector<activation_func> funcs = {
activation_func::linear,
@ -984,7 +984,7 @@ TEST(activation_f16_fw_gpu, basic_bfyx_all_functions)
};
activation_additional_params params = { 3.f, 2.f };
set_values(input_params, { FLOAT16(params.a), FLOAT16(params.b) });
set_values(input_params, { ov::float16(params.a), ov::float16(params.b) });
for (uint8_t i = 0 ; i < 2 ; i++) {
for (auto func : funcs) {
@ -1005,8 +1005,8 @@ TEST(activation_f16_fw_gpu, basic_bfyx_all_functions)
auto output_memory = outputs.at("activation").get_memory();
auto output_layout = output_memory->get_layout();
cldnn::mem_lock<FLOAT16> output_ptr(output_memory, get_test_stream());
cldnn::mem_lock<FLOAT16> input_ptr(input, get_test_stream());
cldnn::mem_lock<ov::float16> output_ptr(output_memory, get_test_stream());
cldnn::mem_lock<ov::float16> input_ptr(input, get_test_stream());
int y_size = output_layout.spatial(1);
int x_size = output_layout.spatial(0);
@ -1021,28 +1021,28 @@ TEST(activation_f16_fw_gpu, basic_bfyx_all_functions)
for (size_t i = 0; i < output_layout.get_linear_size(); ++i) {
switch (func) {
case activation_func::linear: {
VF<FLOAT16> output_vec = {FLOAT16(-11.5f), FLOAT16(-5.5f), FLOAT16(-2.5f), FLOAT16(3.5f),
FLOAT16(4.7f), FLOAT16(6.5f), FLOAT16(8.0f), FLOAT16(9.5f)};
VF<ov::float16> output_vec = {ov::float16(-11.5f), ov::float16(-5.5f), ov::float16(-2.5f), ov::float16(3.5f),
ov::float16(4.7f), ov::float16(6.5f), ov::float16(8.0f), ov::float16(9.5f)};
ASSERT_FLOAT_EQ(output_vec[i], output_ptr[i]);
break;
}
case activation_func::mish:
ASSERT_NEAR((FLOAT16)((float)input_ptr[i] * std::tanh(std::log(1.f + std::exp((float)input_ptr[i])))),
ASSERT_NEAR((ov::float16)((float)input_ptr[i] * std::tanh(std::log(1.f + std::exp((float)input_ptr[i])))),
output_ptr[i], 1e-2f);
break;
case activation_func::hswish:
ASSERT_NEAR((FLOAT16)((float)input_ptr[i] * std::fmin(std::fmax(0.f, (float)input_ptr[i] + 3.f), 6.f) / 6.f),
ASSERT_NEAR((ov::float16)((float)input_ptr[i] * std::fmin(std::fmax(0.f, (float)input_ptr[i] + 3.f), 6.f) / 6.f),
output_ptr[i], 1e-3f);
break;
case activation_func::hard_sigmoid:
ASSERT_NEAR((FLOAT16)(std::fmin(std::fmax(0.f, (float)input_ptr[i] + 3.f), 6.f) / 6.f),
ASSERT_NEAR((ov::float16)(std::fmin(std::fmax(0.f, (float)input_ptr[i] + 3.f), 6.f) / 6.f),
output_ptr[i], 1e-3f);
break;
case activation_func::round_half_to_even:
ASSERT_FLOAT_EQ((FLOAT16)std::rint((float)input_ptr[i]), output_ptr[i]);
ASSERT_FLOAT_EQ((ov::float16)std::rint((float)input_ptr[i]), output_ptr[i]);
break;
case activation_func::round_half_away_from_zero:
ASSERT_FLOAT_EQ((FLOAT16)std::round((float)input_ptr[i]), output_ptr[i]);
ASSERT_FLOAT_EQ((ov::float16)std::round((float)input_ptr[i]), output_ptr[i]);
break;
default:
break;
@ -1804,7 +1804,7 @@ struct activation_random_test : testing::TestWithParam<activation_random_test_pa
fill_random_typed<float>(mem, -127, 127, 2);
break;
case data_types::f16:
fill_random_typed<FLOAT16>(mem, -127, 127, 2);
fill_random_typed<ov::float16>(mem, -127, 127, 2);
break;
case data_types::i8:
fill_random_typed<int8_t>(mem, -127, 127, 1);
@ -1913,7 +1913,7 @@ struct activation_random_test : testing::TestWithParam<activation_random_test_pa
if (input_type == data_types::f32) {
compare_outputs<float>(output, output_opt);
} else if (input_type == data_types::f16) {
compare_outputs<FLOAT16>(output, output_opt);
compare_outputs<ov::float16>(output, output_opt);
} else if (input_type == data_types::i8) {
compare_outputs<int8_t>(output, output_opt);
} else if (input_type == data_types::u8) {

6
src/plugins/intel_gpu/tests/unit/test_cases/adaptive_avg_pooling_gpu_test.cpp
View File

@ -86,7 +86,7 @@ float getError<float>() {
}
template<>
float getError<half_t>() {
float getError<ov::float16>() {
return 0.5;
}
@ -119,7 +119,7 @@ struct adaptive_avg_pooling_test
public:
void test() {
const auto data_type = type_to_data_type<T>::value;
const auto data_type = ov::element::from<T>();
AdaptiveAvgPoolingParams params;
format::type plain_layout;
format::type target_layout;
@ -162,7 +162,7 @@ public:
using adaptive_avg_pooling_test_f32 = adaptive_avg_pooling_test<float>;
using adaptive_avg_pooling_test_f16 = adaptive_avg_pooling_test<half_t>;
using adaptive_avg_pooling_test_f16 = adaptive_avg_pooling_test<ov::float16>;
TEST_P(adaptive_avg_pooling_test_f32, adaptive_avg_pooling_test_f32) {
ASSERT_NO_FATAL_FAILURE(test());

6
src/plugins/intel_gpu/tests/unit/test_cases/adaptive_max_pooling_gpu_test.cpp
View File

@ -91,7 +91,7 @@ float getError<float>() {
}
template<>
float getError<half_t>() {
float getError<ov::float16>() {
return 0.5;
}
@ -124,7 +124,7 @@ struct adaptive_max_pooling_test
public:
void test() {
const auto data_type = type_to_data_type<T>::value;
const auto data_type = ov::element::from<T>();
AdaptiveMaxPoolingParams params;
format::type plain_layout;
format::type target_layout;
@ -218,7 +218,7 @@ public:
using adaptive_max_pooling_test_f32 = adaptive_max_pooling_test<float>;
using adaptive_max_pooling_test_f16 = adaptive_max_pooling_test<half_t>;
using adaptive_max_pooling_test_f16 = adaptive_max_pooling_test<ov::float16>;
TEST_P(adaptive_max_pooling_test_f32, adaptive_max_pooling_test_f32) {
ASSERT_NO_FATAL_FAILURE(test());

7
src/plugins/intel_gpu/tests/unit/test_cases/arg_max_gpu_test.cpp
View File

@ -21,14 +21,13 @@ template <format::type layoutFormat, typename DataType>
struct arg_max_input_types {
static const auto format = layoutFormat;
using input_type = DataType;
static const data_types data_type = type_to_data_type<DataType>::value;
};
template <typename ArgMaxInput>
struct argmax_gpu_test : public testing::Test {
static const auto format = ArgMaxInput::format;
using input_type = typename ArgMaxInput::input_type;
static const data_types data_type = ArgMaxInput::data_type;
const data_types data_type = ov::element::from<input_type>();
std::vector<input_type> getTypedVector(const std::vector<float>& input) {
return std::vector<input_type>(input.begin(), input.end());
}
@ -54,8 +53,8 @@ using format_types = testing::Types<arg_max_input_types<format::bfyx, float>,
arg_max_input_types<format::bs_fs_yx_bsv16_fsv16, int32_t>,
arg_max_input_types<format::bs_fs_yx_bsv32_fsv16, int32_t>,
arg_max_input_types<format::bs_fs_yx_bsv32_fsv32, int32_t>,
arg_max_input_types<format::bfyx, half_t>,
arg_max_input_types<format::bs_fs_yx_bsv32_fsv16, half_t>,
arg_max_input_types<format::bfyx, ov::float16>,
arg_max_input_types<format::bs_fs_yx_bsv32_fsv16, ov::float16>,
arg_max_input_types<format::bfyx, int8_t>,
arg_max_input_types<format::bs_fs_yx_bsv32_fsv16, int8_t>>;

76
src/plugins/intel_gpu/tests/unit/test_cases/batch_to_space_gpu_test.cpp
View File

@ -26,10 +26,10 @@ TEST(batch_to_space_fp16_gpu, i8111_bs1222_cb0000_ce0000) {
auto input = engine.allocate_memory({ data_types::f16, format::bfyx, input_shape });
set_values(input, {
FLOAT16(0.0f), FLOAT16(1.0f),
FLOAT16(2.0f), FLOAT16(3.0f),
FLOAT16(4.0f), FLOAT16(5.0f),
FLOAT16(6.0f), FLOAT16(7.0f)
ov::float16(0.0f), ov::float16(1.0f),
ov::float16(2.0f), ov::float16(3.0f),
ov::float16(4.0f), ov::float16(5.0f),
ov::float16(6.0f), ov::float16(7.0f)
});
topology topology;
@ -71,12 +71,12 @@ TEST(batch_to_space_fp16_gpu, i4321_bs1212_cb0000_ce0000) {
auto input = engine.allocate_memory({ data_types::f16, format::bfyx, input_shape });
set_values(input, {
FLOAT16(0.0f), FLOAT16(1.0f), FLOAT16(2.0f), FLOAT16(3.0f),
FLOAT16(4.0f), FLOAT16(5.0f), FLOAT16(6.0f), FLOAT16(7.0f),
FLOAT16(8.0f), FLOAT16(9.0f), FLOAT16(10.0f), FLOAT16(11.0f),
FLOAT16(12.0f), FLOAT16(13.0f), FLOAT16(14.0f), FLOAT16(15.0f),
FLOAT16(16.0f), FLOAT16(17.0f), FLOAT16(18.0f), FLOAT16(19.0f),
FLOAT16(20.0f), FLOAT16(21.0f), FLOAT16(22.0f), FLOAT16(23.0f)
ov::float16(0.0f), ov::float16(1.0f), ov::float16(2.0f), ov::float16(3.0f),
ov::float16(4.0f), ov::float16(5.0f), ov::float16(6.0f), ov::float16(7.0f),
ov::float16(8.0f), ov::float16(9.0f), ov::float16(10.0f), ov::float16(11.0f),
ov::float16(12.0f), ov::float16(13.0f), ov::float16(14.0f), ov::float16(15.0f),
ov::float16(16.0f), ov::float16(17.0f), ov::float16(18.0f), ov::float16(19.0f),
ov::float16(20.0f), ov::float16(21.0f), ov::float16(22.0f), ov::float16(23.0f)
});
topology topology;
@ -121,12 +121,12 @@ TEST(batch_to_space_fp16_gpu, i4321_bs1212_cb0010_ce0101) {
auto input = engine.allocate_memory({ data_types::f16, format::bfyx, input_shape });
set_values(input, {
FLOAT16(0.0f), FLOAT16(1.0f), FLOAT16(2.0f), FLOAT16(3.0f),
FLOAT16(4.0f), FLOAT16(5.0f), FLOAT16(6.0f), FLOAT16(7.0f),
FLOAT16(8.0f), FLOAT16(9.0f), FLOAT16(10.0f), FLOAT16(11.0f),
FLOAT16(12.0f), FLOAT16(13.0f), FLOAT16(14.0f), FLOAT16(15.0f),
FLOAT16(16.0f), FLOAT16(17.0f), FLOAT16(18.0f), FLOAT16(19.0f),
FLOAT16(20.0f), FLOAT16(21.0f), FLOAT16(22.0f), FLOAT16(23.0f)
ov::float16(0.0f), ov::float16(1.0f), ov::float16(2.0f), ov::float16(3.0f),
ov::float16(4.0f), ov::float16(5.0f), ov::float16(6.0f), ov::float16(7.0f),
ov::float16(8.0f), ov::float16(9.0f), ov::float16(10.0f), ov::float16(11.0f),
ov::float16(12.0f), ov::float16(13.0f), ov::float16(14.0f), ov::float16(15.0f),
ov::float16(16.0f), ov::float16(17.0f), ov::float16(18.0f), ov::float16(19.0f),
ov::float16(20.0f), ov::float16(21.0f), ov::float16(22.0f), ov::float16(23.0f)
});
topology topology;
@ -168,12 +168,12 @@ TEST(batch_to_space_fp16_gpu, i62121_bs12311_cb02000_ce00110) {
auto input = engine.allocate_memory({ data_types::f16, format::bfzyx, input_shape });
set_values(input, {
FLOAT16(0.0f), FLOAT16(1.0f), FLOAT16(2.0f), FLOAT16(3.0f),
FLOAT16(4.0f), FLOAT16(5.0f), FLOAT16(6.0f), FLOAT16(7.0f),
FLOAT16(8.0f), FLOAT16(9.0f), FLOAT16(10.0f), FLOAT16(11.0f),
FLOAT16(12.0f), FLOAT16(13.0f), FLOAT16(14.0f), FLOAT16(15.0f),
FLOAT16(16.0f), FLOAT16(17.0f), FLOAT16(18.0f), FLOAT16(19.0f),
FLOAT16(20.0f), FLOAT16(21.0f), FLOAT16(22.0f), FLOAT16(23.0f)
ov::float16(0.0f), ov::float16(1.0f), ov::float16(2.0f), ov::float16(3.0f),
ov::float16(4.0f), ov::float16(5.0f), ov::float16(6.0f), ov::float16(7.0f),
ov::float16(8.0f), ov::float16(9.0f), ov::float16(10.0f), ov::float16(11.0f),
ov::float16(12.0f), ov::float16(13.0f), ov::float16(14.0f), ov::float16(15.0f),
ov::float16(16.0f), ov::float16(17.0f), ov::float16(18.0f), ov::float16(19.0f),
ov::float16(20.0f), ov::float16(21.0f), ov::float16(22.0f), ov::float16(23.0f)
});
topology topology;
@ -215,14 +215,14 @@ TEST(batch_to_space_fp16_gpu, i1212112_bs112321_cb02000_ce00110) {
auto input = engine.allocate_memory({ data_types::f16, format::bfwzyx, input_shape });
set_values(input, {
FLOAT16(0.0f), FLOAT16(1.0f), FLOAT16(2.0f), FLOAT16(3.0f),
FLOAT16(4.0f), FLOAT16(5.0f), FLOAT16(6.0f), FLOAT16(7.0f),
FLOAT16(8.0f), FLOAT16(9.0f), FLOAT16(10.0f), FLOAT16(11.0f),
FLOAT16(12.0f), FLOAT16(13.0f), FLOAT16(14.0f), FLOAT16(15.0f),
FLOAT16(16.0f), FLOAT16(17.0f), FLOAT16(18.0f), FLOAT16(19.0f),
FLOAT16(20.0f), FLOAT16(21.0f), FLOAT16(22.0f), FLOAT16(23.0f),
FLOAT16(24.0f), FLOAT16(25.0f), FLOAT16(26.0f), FLOAT16(27.0f),
FLOAT16(28.0f), FLOAT16(29.0f), FLOAT16(30.0f), FLOAT16(31.0f)
ov::float16(0.0f), ov::float16(1.0f), ov::float16(2.0f), ov::float16(3.0f),
ov::float16(4.0f), ov::float16(5.0f), ov::float16(6.0f), ov::float16(7.0f),
ov::float16(8.0f), ov::float16(9.0f), ov::float16(10.0f), ov::float16(11.0f),
ov::float16(12.0f), ov::float16(13.0f), ov::float16(14.0f), ov::float16(15.0f),
ov::float16(16.0f), ov::float16(17.0f), ov::float16(18.0f), ov::float16(19.0f),
ov::float16(20.0f), ov::float16(21.0f), ov::float16(22.0f), ov::float16(23.0f),
ov::float16(24.0f), ov::float16(25.0f), ov::float16(26.0f), ov::float16(27.0f),
ov::float16(28.0f), ov::float16(29.0f), ov::float16(30.0f), ov::float16(31.0f)
});
topology topology;
@ -266,10 +266,10 @@ TEST(batch_to_space_fp16_gpu, i21611_bs1112_cb0000_ce0000_b_fs_yx_fsv16) {
auto input = engine.allocate_memory({ data_types::f16, format::bfyx, input_shape });
set_values(input, {
FLOAT16(0.0f), FLOAT16(1.0f), FLOAT16(2.0f), FLOAT16(3.0f), FLOAT16(4.0f), FLOAT16(5.0f), FLOAT16(6.0f), FLOAT16(7.0f),
FLOAT16(8.0f), FLOAT16(9.0f), FLOAT16(10.0f), FLOAT16(11.0f), FLOAT16(12.0f), FLOAT16(13.0f), FLOAT16(14.0f), FLOAT16(15.0f),
FLOAT16(16.0f), FLOAT16(17.0f), FLOAT16(18.0f), FLOAT16(19.0f), FLOAT16(20.0f), FLOAT16(21.0f), FLOAT16(22.0f), FLOAT16(23.0f),
FLOAT16(24.0f), FLOAT16(25.0f), FLOAT16(26.0f), FLOAT16(27.0f), FLOAT16(28.0f), FLOAT16(29.0f), FLOAT16(30.0f), FLOAT16(31.0f)
ov::float16(0.0f), ov::float16(1.0f), ov::float16(2.0f), ov::float16(3.0f), ov::float16(4.0f), ov::float16(5.0f), ov::float16(6.0f), ov::float16(7.0f),
ov::float16(8.0f), ov::float16(9.0f), ov::float16(10.0f), ov::float16(11.0f), ov::float16(12.0f), ov::float16(13.0f), ov::float16(14.0f), ov::float16(15.0f),
ov::float16(16.0f), ov::float16(17.0f), ov::float16(18.0f), ov::float16(19.0f), ov::float16(20.0f), ov::float16(21.0f), ov::float16(22.0f), ov::float16(23.0f),
ov::float16(24.0f), ov::float16(25.0f), ov::float16(26.0f), ov::float16(27.0f), ov::float16(28.0f), ov::float16(29.0f), ov::float16(30.0f), ov::float16(31.0f)
});
topology topology;
@ -317,10 +317,10 @@ TEST(batch_to_space_fp16_gpu, i2812_bs1112_cb0000_ce0000_b_fs_yx_fsv16) {
auto input = engine.allocate_memory({ data_types::f16, format::bfyx, input_shape });
set_values(input, {
FLOAT16(0.0f), FLOAT16(1.0f), FLOAT16(2.0f), FLOAT16(3.0f), FLOAT16(4.0f), FLOAT16(5.0f), FLOAT16(6.0f), FLOAT16(7.0f),
FLOAT16(8.0f), FLOAT16(9.0f), FLOAT16(10.0f), FLOAT16(11.0f), FLOAT16(12.0f), FLOAT16(13.0f), FLOAT16(14.0f), FLOAT16(15.0f),
FLOAT16(16.0f), FLOAT16(17.0f), FLOAT16(18.0f), FLOAT16(19.0f), FLOAT16(20.0f), FLOAT16(21.0f), FLOAT16(22.0f), FLOAT16(23.0f),
FLOAT16(24.0f), FLOAT16(25.0f), FLOAT16(26.0f), FLOAT16(27.0f), FLOAT16(28.0f), FLOAT16(29.0f), FLOAT16(30.0f), FLOAT16(31.0f)
ov::float16(0.0f), ov::float16(1.0f), ov::float16(2.0f), ov::float16(3.0f), ov::float16(4.0f), ov::float16(5.0f), ov::float16(6.0f), ov::float16(7.0f),
ov::float16(8.0f), ov::float16(9.0f), ov::float16(10.0f), ov::float16(11.0f), ov::float16(12.0f), ov::float16(13.0f), ov::float16(14.0f), ov::float16(15.0f),
ov::float16(16.0f), ov::float16(17.0f), ov::float16(18.0f), ov::float16(19.0f), ov::float16(20.0f), ov::float16(21.0f), ov::float16(22.0f), ov::float16(23.0f),
ov::float16(24.0f), ov::float16(25.0f), ov::float16(26.0f), ov::float16(27.0f), ov::float16(28.0f), ov::float16(29.0f), ov::float16(30.0f), ov::float16(31.0f)
});
topology topology;

12
src/plugins/intel_gpu/tests/unit/test_cases/binary_convolution_gpu_test.cpp
View File

@ -210,8 +210,8 @@ TEST_P(binary_convolution_test, conv) {
cldnn::feature(p.oc),
cldnn::spatial(p.ow, p.oh)};
auto input = engine.allocate_memory({ cldnn::data_types::bin, cldnn::format::b_fs_yx_32fp, is_size });
auto weights = engine.allocate_memory({ cldnn::data_types::bin, cldnn::format::bfyx, wei_size });
auto input = engine.allocate_memory({ cldnn::data_types::u1, cldnn::format::b_fs_yx_32fp, is_size });
auto weights = engine.allocate_memory({ cldnn::data_types::u1, cldnn::format::bfyx, wei_size });
auto output_ref = engine.allocate_memory({ cldnn::data_types::f32, cldnn::format::bfyx, os_size });
fill(input);
@ -329,8 +329,8 @@ TEST(binary_convolution, basic_convolution_1x1_single_packed_channel) {
if(engine.get_device_info().supports_immad)
return;
auto input = engine.allocate_memory({ data_types::bin, format::b_fs_yx_32fp, { 1, 16, 2, 2 } });
auto weights = engine.allocate_memory({ data_types::bin, format::bfyx, { 4, 16, 1, 1 } });
auto input = engine.allocate_memory({ data_types::u1, format::b_fs_yx_32fp, { 1, 16, 2, 2 } });
auto weights = engine.allocate_memory({ data_types::u1, format::bfyx, { 4, 16, 1, 1 } });
// 0 0 1 0 0 1 0 0 1 0 1 0 1 0 1 0
// 1 0 0 0 0 1 1 0 0 1 1 0 1 0 1 0
@ -415,8 +415,8 @@ TEST(binary_convolution, basic_convolution_1x1_single_packed_channel_fp16) {
if(engine.get_device_info().supports_immad)
return;
auto input = engine.allocate_memory({ data_types::bin, format::b_fs_yx_32fp, { 1, 16, 2, 2 } });
auto weights = engine.allocate_memory({ data_types::bin, format::bfyx, { 4, 16, 1, 1 } });
auto input = engine.allocate_memory({ data_types::u1, format::b_fs_yx_32fp, { 1, 16, 2, 2 } });
auto weights = engine.allocate_memory({ data_types::u1, format::bfyx, { 4, 16, 1, 1 } });
// 0 0 1 0 0 1 0 0 1 0 1 0 1 0 1 0
// 1 0 0 0 0 1 1 0 0 1 1 0 1 0 1 0

10
src/plugins/intel_gpu/tests/unit/test_cases/border_gpu_test.cpp
View File

@ -165,12 +165,12 @@ INSTANTIATE_TEST_SUITE_P(negative_pads,
testing::Values(true),
testing::Values(false)));
using border_test_f16 = border_test<FLOAT16, data_types::f16>;
using border_test_f16 = border_test<ov::float16, data_types::f16>;
TEST_P(border_test_f16, border_test_f16) {}
INSTANTIATE_TEST_SUITE_P(border_test_f16,
border_test_f16,
testing::Combine(testing::Values(ov::op::PadMode::REFLECT),
testing::Values(FLOAT16(123)),
testing::Values(ov::float16(123)),
testing::Values(format::type::bs_fs_yx_bsv32_fsv16),
testing::Values(std::array<int, 4>{2, 3, 4, 5}),
testing::Values(std::array<int, 4>{1, 2, 3, 4}),
@ -180,7 +180,7 @@ INSTANTIATE_TEST_SUITE_P(border_test_f16,
INSTANTIATE_TEST_SUITE_P(export_import,
border_test_f16,
testing::Combine(testing::Values(ov::op::PadMode::REFLECT),
testing::Values(FLOAT16(123)),
testing::Values(ov::float16(123)),
testing::Values(format::type::bs_fs_yx_bsv32_fsv16),
testing::Values(std::array<int, 4>{2, 3, 4, 5}),
testing::Values(std::array<int, 4>{1, 2, 3, 4}),
@ -1830,7 +1830,7 @@ TEST(border_gpu, basic_zero_input_dynamic) {
auto& engine = get_test_engine();
// WA to avoid crash due to attempt to allocate 0 bytes for USM memory
layout fake_input_layout = {{1}, data_types::bin, format::bfyx};
layout fake_input_layout = {{1}, data_types::undefined, format::bfyx};
auto input = engine.allocate_memory(fake_input_layout);
layout zero_input_layout = {{0, 1}, data_types::f32, format::bfyx};
@ -1878,7 +1878,7 @@ TEST(border_gpu, basic_zero_input) {
auto& engine = get_test_engine();
// WA to avoid crash due to attempt to allocate 0 bytes for USM memory
layout fake_input_layout = {{1}, data_types::bin, format::bfyx};
layout fake_input_layout = {{1}, data_types::u8, format::bfyx};
auto input = engine.allocate_memory(fake_input_layout);
layout zero_input_layout = {{0, 1}, data_types::f32, format::bfyx};

146
src/plugins/intel_gpu/tests/unit/test_cases/broadcast_gpu_test.cpp
View File

@ -1208,11 +1208,11 @@ TEST(broadcast_gpu_int8_t, bs_fs_yx_bsv32_fsv32_1x38x1x1_to_1x38x1x5_w_b_axes_0)
}
TEST(broadcast_gpu_fp16, b_fs_yx_fsv16_1x38x1x1_to_1x38x1x5_w_b_axes_0) {
start_broadcast_test<FLOAT16>(format::b_fs_yx_fsv16, data_types::f16, {1, 38, 1, 5}, {1, 38, 1, 1}, {0});
start_broadcast_test<ov::float16>(format::b_fs_yx_fsv16, data_types::f16, {1, 38, 1, 5}, {1, 38, 1, 1}, {0});
}
TEST(broadcast_gpu_fp16, bs_fs_yx_bsv32_fsv16_1x38x1x1_to_1x38x1x5_w_b_axes_0) {
start_broadcast_test<FLOAT16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {1, 38, 1, 5}, {1, 38, 1, 1}, {0});
start_broadcast_test<ov::float16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {1, 38, 1, 5}, {1, 38, 1, 1}, {0});
}
@ -1237,11 +1237,11 @@ TEST(broadcast_gpu_int8_t, bs_fs_yx_bsv32_fsv32_1_to_4x5_w_b_axes_0x1) {
}
TEST(broadcast_gpu_fp16, b_fs_yx_fsv16_1_to_4x5_w_b_axes_0x1) {
start_broadcast_test<FLOAT16>(format::b_fs_yx_fsv16, data_types::f16, {4, 5}, {1}, {0, 1});
start_broadcast_test<ov::float16>(format::b_fs_yx_fsv16, data_types::f16, {4, 5}, {1}, {0, 1});
}
TEST(broadcast_gpu_fp16, bs_fs_yx_bsv32_fsv16_1_to_4x5_w_b_axes_0x1) {
start_broadcast_test<FLOAT16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {4, 5}, {1}, {0, 1});
start_broadcast_test<ov::float16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {4, 5}, {1}, {0, 1});
}
@ -1266,11 +1266,11 @@ TEST(broadcast_gpu_int8_t, bs_fs_yx_bsv32_fsv32_1_to_3x4x5_w_b_axes_0x1x2) {
}
TEST(broadcast_gpu_fp16, b_fs_yx_fsv16_1_to_3x4x5_w_b_axes_0x1x2) {
start_broadcast_test<FLOAT16>(format::b_fs_yx_fsv16, data_types::f16, {3, 4, 5}, {1}, {0, 1, 2});
start_broadcast_test<ov::float16>(format::b_fs_yx_fsv16, data_types::f16, {3, 4, 5}, {1}, {0, 1, 2});
}
TEST(broadcast_gpu_fp16, bs_fs_yx_bsv32_fsv16_1_to_3x4x5_w_b_axes_0x1x2) {
start_broadcast_test<FLOAT16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {3, 4, 5}, {1}, {0, 1, 2});
start_broadcast_test<ov::float16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {3, 4, 5}, {1}, {0, 1, 2});
}
@ -1295,11 +1295,11 @@ TEST(broadcast_gpu_int8_t, bs_fs_yx_bsv32_fsv16_1_to_2x3x4x5_w_b_axes_0x1x2x3) {
}
TEST(broadcast_gpu_fp16, b_fs_yx_fsv16_1_to_2x3x4x5_w_b_axes_0x1x2x3) {
start_broadcast_test<FLOAT16>(format::b_fs_yx_fsv16, data_types::f16, {2, 3, 4, 5}, {1}, {0, 1, 2, 3});
start_broadcast_test<ov::float16>(format::b_fs_yx_fsv16, data_types::f16, {2, 3, 4, 5}, {1}, {0, 1, 2, 3});
}
TEST(broadcast_gpu_fp16, bs_fs_yx_bsv32_fsv16_1_to_2x3x4x5_w_b_axes_0x1x2x3) {
start_broadcast_test<FLOAT16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {2, 3, 4, 5}, {1}, {0, 1, 2, 3});
start_broadcast_test<ov::float16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {2, 3, 4, 5}, {1}, {0, 1, 2, 3});
}
@ -1324,11 +1324,11 @@ TEST(broadcast_gpu_int8_t, bs_fs_yx_bsv32_fsv32_42x36x1x1_to_42x36x1x5_w_o_b_axe
}
TEST(broadcast_gpu_fp16, b_fs_yx_fsv16_42x36x1x1_to_42x36x1x5_w_o_b_axes) {
start_broadcast_test<FLOAT16>(format::b_fs_yx_fsv16, data_types::f16, {42, 36, 1, 5}, {42, 36, 1, 1}, {});
start_broadcast_test<ov::float16>(format::b_fs_yx_fsv16, data_types::f16, {42, 36, 1, 5}, {42, 36, 1, 1}, {});
}
TEST(broadcast_gpu_fp16, bs_fs_yx_bsv32_fsv16_42x36x1x1_to_42x36x1x5_w_o_b_axes) {
start_broadcast_test<FLOAT16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {42, 36, 1, 5}, {42, 36, 1, 1}, {});
start_broadcast_test<ov::float16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {42, 36, 1, 5}, {42, 36, 1, 1}, {});
}
@ -1353,11 +1353,11 @@ TEST(broadcast_gpu_int8_t, bs_fs_yx_bsv32_fsv32_35x32x1x3_to_140x128x1x12_w_o_b_
}
TEST(broadcast_gpu_fp16, b_fs_yx_fsv16_35x32x1x3_to_140x128x1x12_w_o_b_axes) {
start_broadcast_test<FLOAT16>(format::b_fs_yx_fsv16, data_types::f16, {140, 128, 1, 12}, {35, 32, 1, 3}, {});
start_broadcast_test<ov::float16>(format::b_fs_yx_fsv16, data_types::f16, {140, 128, 1, 12}, {35, 32, 1, 3}, {});
}
TEST(broadcast_gpu_fp16, bs_fs_yx_bsv32_fsv16_35x32x1x3_to_140x128x1x12_w_o_b_axes) {
start_broadcast_test<FLOAT16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {140, 128, 1, 12}, {35, 32, 1, 3}, {});
start_broadcast_test<ov::float16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {140, 128, 1, 12}, {35, 32, 1, 3}, {});
}
@ -1382,11 +1382,11 @@ TEST(broadcast_gpu_int8_t, bs_fs_yx_bsv32_fsv32_42x64x1x1_to_84x128x4x5_w_o_b_ax
}
TEST(broadcast_gpu_fp16, b_fs_yx_fsv16_42x64x1x1_to_84x128x4x5_w_o_b_axes) {
start_broadcast_test<FLOAT16>(format::b_fs_yx_fsv16, data_types::f16, {84, 128, 4, 5}, {42, 64, 1, 1}, {});
start_broadcast_test<ov::float16>(format::b_fs_yx_fsv16, data_types::f16, {84, 128, 4, 5}, {42, 64, 1, 1}, {});
}
TEST(broadcast_gpu_fp16, bs_fs_yx_bsv32_fsv16_42x64x1x1_to_84x128x4x5_w_o_b_axes) {
start_broadcast_test<FLOAT16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {84, 128, 4, 5}, {42, 64, 1, 1}, {});
start_broadcast_test<ov::float16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {84, 128, 4, 5}, {42, 64, 1, 1}, {});
}
@ -1411,11 +1411,11 @@ TEST(broadcast_gpu_int8_t, bs_fs_yx_bsv32_fsv32_156x78x2x3_to_156x156x8x6_w_o_b_
}
TEST(broadcast_gpu_fp16, b_fs_yx_fsv16_156x78x2x3_to_156x156x8x6_w_o_b_axes) {
start_broadcast_test<FLOAT16>(format::b_fs_yx_fsv16, data_types::f16, {156, 156, 8, 6}, {156, 78, 2, 3}, {});
start_broadcast_test<ov::float16>(format::b_fs_yx_fsv16, data_types::f16, {156, 156, 8, 6}, {156, 78, 2, 3}, {});
}
TEST(broadcast_gpu_fp16, bs_fs_yx_bsv32_fsv16_156x78x2x3_to_156x156x8x6_w_o_b_axes) {
start_broadcast_test<FLOAT16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {156, 156, 8, 6}, {156, 78, 2, 3}, {});
start_broadcast_test<ov::float16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {156, 156, 8, 6}, {156, 78, 2, 3}, {});
}
@ -1440,11 +1440,11 @@ TEST(broadcast_gpu_int8_t, bs_fs_yx_bsv32_fsv32_42x2x3x4_to_126x6x6x4_w_o_b_axes
}
TEST(broadcast_gpu_fp16, b_fs_yx_fsv16_42x2x3x4_to_126x6x6x4_w_o_b_axes) {
start_broadcast_test<FLOAT16>(format::b_fs_yx_fsv16, data_types::f16, {126, 6, 6, 4}, {42, 2, 3, 4}, {});
start_broadcast_test<ov::float16>(format::b_fs_yx_fsv16, data_types::f16, {126, 6, 6, 4}, {42, 2, 3, 4}, {});
}
TEST(broadcast_gpu_fp16, bs_fs_yx_bsv32_fsv16_42x2x3x4_to_126x6x6x4_w_o_b_axes) {
start_broadcast_test<FLOAT16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {126, 6, 6, 4}, {42, 2, 3, 4}, {});
start_broadcast_test<ov::float16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {126, 6, 6, 4}, {42, 2, 3, 4}, {});
}
@ -1469,11 +1469,11 @@ TEST(broadcast_gpu_int8_t, bs_fs_yx_bsv32_fsv32_256x91x4x5_to_256x273x8x5_w_o_b_
}
TEST(broadcast_gpu_fp16, b_fs_yx_fsv16_256x91x4x5_to_256x273x8x5_w_o_b_axes) {
start_broadcast_test<FLOAT16>(format::b_fs_yx_fsv16, data_types::f16, {256, 273, 8, 5}, {256, 91, 4, 5}, {});
start_broadcast_test<ov::float16>(format::b_fs_yx_fsv16, data_types::f16, {256, 273, 8, 5}, {256, 91, 4, 5}, {});
}
TEST(broadcast_gpu_fp16, bs_fs_yx_bsv32_fsv16_256x91x4x5_to_256x273x8x5_w_o_b_axes) {
start_broadcast_test<FLOAT16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {256, 273, 8, 5}, {256, 91, 4, 5}, {});
start_broadcast_test<ov::float16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {256, 273, 8, 5}, {256, 91, 4, 5}, {});
}
@ -1498,11 +1498,11 @@ TEST(broadcast_gpu_int8_t, bs_fs_yx_bsv32_fsv326_1x45x1x3_to_1x45x2x3_w_b_axes_0
}
TEST(broadcast_gpu_fp16, b_fs_yx_fsv166_1x45x1x3_to_1x45x2x3_w_b_axes_0) {
start_broadcast_test<FLOAT16>(format::b_fs_yx_fsv16, data_types::f16, {1, 45, 2, 3}, {1, 45, 1, 3}, {0});
start_broadcast_test<ov::float16>(format::b_fs_yx_fsv16, data_types::f16, {1, 45, 2, 3}, {1, 45, 1, 3}, {0});
}
TEST(broadcast_gpu_fp16, bs_fs_yx_bsv32_fsv166_1x45x1x3_to_1x45x2x3_w_b_axes_0) {
start_broadcast_test<FLOAT16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {1, 45, 2, 3}, {1, 45, 1, 3}, {0});
start_broadcast_test<ov::float16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {1, 45, 2, 3}, {1, 45, 1, 3}, {0});
}
@ -1527,11 +1527,11 @@ TEST(broadcast_gpu_int8_t, bs_fs_yx_bsv32_fsv32_1x62x1x3_to_1x62x2x6_w_b_axes_0)
}
TEST(broadcast_gpu_fp16, b_fs_yx_fsv16_1x62x1x3_to_1x62x2x6_w_b_axes_0) {
start_broadcast_test<FLOAT16>(format::b_fs_yx_fsv16, data_types::f16, {1, 62, 2, 6}, {1, 62, 1, 3}, {0});
start_broadcast_test<ov::float16>(format::b_fs_yx_fsv16, data_types::f16, {1, 62, 2, 6}, {1, 62, 1, 3}, {0});
}
TEST(broadcast_gpu_fp16, bs_fs_yx_bsv32_fsv16_1x62x1x3_to_1x62x2x6_w_b_axes_0) {
start_broadcast_test<FLOAT16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {1, 62, 2, 6}, {1, 62, 1, 3}, {0});
start_broadcast_test<ov::float16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {1, 62, 2, 6}, {1, 62, 1, 3}, {0});
}
@ -1556,11 +1556,11 @@ TEST(broadcast_gpu_int8_t, bs_fs_yx_bsv32_fsv32_2_to_2x3_w_b_axes_1) {
}
TEST(broadcast_gpu_fp16, b_fs_yx_fsv16_2_to_2x3_w_b_axes_1) {
start_broadcast_test<FLOAT16>(format::b_fs_yx_fsv16, data_types::f16, {2, 3}, {2}, {1});
start_broadcast_test<ov::float16>(format::b_fs_yx_fsv16, data_types::f16, {2, 3}, {2}, {1});
}
TEST(broadcast_gpu_fp16, bs_fs_yx_bsv32_fsv16_2_to_2x3_w_b_axes_1) {
start_broadcast_test<FLOAT16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {2, 3}, {2}, {1});
start_broadcast_test<ov::float16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {2, 3}, {2}, {1});
}
@ -1585,11 +1585,11 @@ TEST(broadcast_gpu_int8_t, bs_fs_yx_bsv32_fsv32_2_to_6x3_w_b_axes_1) {
}
TEST(broadcast_gpu_fp16, b_fs_yx_fsv16_2_to_6x3_w_b_axes_1) {
start_broadcast_test<FLOAT16>(format::b_fs_yx_fsv16, data_types::f16, {6, 3}, {2}, {1});
start_broadcast_test<ov::float16>(format::b_fs_yx_fsv16, data_types::f16, {6, 3}, {2}, {1});
}
TEST(broadcast_gpu_fp16, bs_fs_yx_bsv32_fsv16_2_to_6x3_w_b_axes_1) {
start_broadcast_test<FLOAT16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {6, 3}, {2}, {1});
start_broadcast_test<ov::float16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {6, 3}, {2}, {1});
}
@ -1614,11 +1614,11 @@ TEST(broadcast_gpu_int8_t, bs_fs_yx_bsv32_fsv32_1x76x3x4_to_1x152x3x4_w_b_axes_0
}
TEST(broadcast_gpu_fp16, b_fs_yx_fsv16_1x76x3x4_to_1x152x3x4_w_b_axes_0) {
start_broadcast_test<FLOAT16>(format::b_fs_yx_fsv16, data_types::f16, {1, 152, 3, 4}, {1, 76, 3, 4}, {0});
start_broadcast_test<ov::float16>(format::b_fs_yx_fsv16, data_types::f16, {1, 152, 3, 4}, {1, 76, 3, 4}, {0});
}
TEST(broadcast_gpu_fp16, bs_fs_yx_bsv32_fsv16_1x76x3x4_to_1x152x3x4_w_b_axes_0) {
start_broadcast_test<FLOAT16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {1, 152, 3, 4}, {1, 76, 3, 4}, {0});
start_broadcast_test<ov::float16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {1, 152, 3, 4}, {1, 76, 3, 4}, {0});
}
@ -1643,11 +1643,11 @@ TEST(broadcast_gpu_int8_t, bs_fs_yx_bsv32_fsv32_2x4_to_2x3x4_w_b_axes_1) {
}
TEST(broadcast_gpu_fp16, b_fs_yx_fsv16_2x4_to_2x3x4_w_b_axes_1) {
start_broadcast_test<FLOAT16>(format::b_fs_yx_fsv16, data_types::f16, {2, 3, 4}, {2, 4}, {1});
start_broadcast_test<ov::float16>(format::b_fs_yx_fsv16, data_types::f16, {2, 3, 4}, {2, 4}, {1});
}
TEST(broadcast_gpu_fp16, bs_fs_yx_bsv32_fsv16_2x4_to_2x3x4_w_b_axes_1) {
start_broadcast_test<FLOAT16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {2, 3, 4}, {2, 4}, {1});
start_broadcast_test<ov::float16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {2, 3, 4}, {2, 4}, {1});
}
@ -1672,11 +1672,11 @@ TEST(broadcast_gpu_int8_t, bs_fs_yx_bsv32_fsv32_2x3_to_2x3x4_w_b_axes_2) {
}
TEST(broadcast_gpu_fp16, b_fs_yx_fsv16_2x3_to_2x3x4_w_b_axes_2) {
start_broadcast_test<FLOAT16>(format::b_fs_yx_fsv16, data_types::f16, {2, 3, 4}, {2, 3}, {2});
start_broadcast_test<ov::float16>(format::b_fs_yx_fsv16, data_types::f16, {2, 3, 4}, {2, 3}, {2});
}
TEST(broadcast_gpu_fp16, bs_fs_yx_bsv32_fsv16_2x3_to_2x3x4_w_b_axes_2) {
start_broadcast_test<FLOAT16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {2, 3, 4}, {2, 3}, {2});
start_broadcast_test<ov::float16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {2, 3, 4}, {2, 3}, {2});
}
@ -1701,11 +1701,11 @@ TEST(broadcast_gpu_int8_t, bs_fs_yx_bsv32_fsv32_4_to_2x3x4_w_b_axes_0_1) {
}
TEST(broadcast_gpu_fp16, b_fs_yx_fsv16_4_to_2x3x4_w_b_axes_0_1) {
start_broadcast_test<FLOAT16>(format::b_fs_yx_fsv16, data_types::f16, {2, 3, 4}, {4}, {0, 1});
start_broadcast_test<ov::float16>(format::b_fs_yx_fsv16, data_types::f16, {2, 3, 4}, {4}, {0, 1});
}
TEST(broadcast_gpu_fp16, bs_fs_yx_bsv32_fsv16_4_to_2x3x4_w_b_axes_0_1) {
start_broadcast_test<FLOAT16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {2, 3, 4}, {4}, {0, 1});
start_broadcast_test<ov::float16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {2, 3, 4}, {4}, {0, 1});
}
@ -1730,11 +1730,11 @@ TEST(broadcast_gpu_int8_t, bs_fs_yx_bsv32_fsv32_3_to_2x3x4_w_b_axes_0_2) {
}
TEST(broadcast_gpu_fp16, b_fs_yx_fsv16_3_to_2x3x4_w_b_axes_0_2) {
start_broadcast_test<FLOAT16>(format::b_fs_yx_fsv16, data_types::f16, {2, 3, 4}, {3}, {0, 2});
start_broadcast_test<ov::float16>(format::b_fs_yx_fsv16, data_types::f16, {2, 3, 4}, {3}, {0, 2});
}
TEST(broadcast_gpu_fp16, bs_fs_yx_bsv32_fsv16_3_to_2x3x4_w_b_axes_0_2) {
start_broadcast_test<FLOAT16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {2, 3, 4}, {3}, {0, 2});
start_broadcast_test<ov::float16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {2, 3, 4}, {3}, {0, 2});
}
@ -1759,11 +1759,11 @@ TEST(broadcast_gpu_int8_t, bs_fs_yx_bsv32_fsv16_2_to_2x3x4_w_b_axes_1_2) {
}
TEST(broadcast_gpu_fp16, b_fs_yx_fsv16_2_to_2x3x4_w_b_axes_1_2) {
start_broadcast_test<FLOAT16>(format::b_fs_yx_fsv16, data_types::f16, {2, 3, 4}, {2}, {1, 2});
start_broadcast_test<ov::float16>(format::b_fs_yx_fsv16, data_types::f16, {2, 3, 4}, {2}, {1, 2});
}
TEST(broadcast_gpu_fp16, bs_fs_yx_bsv32_fsv16_2_to_2x3x4_w_b_axes_1_2) {
start_broadcast_test<FLOAT16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {2, 3, 4}, {2}, {1, 2});
start_broadcast_test<ov::float16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {2, 3, 4}, {2}, {1, 2});
}
@ -1788,11 +1788,11 @@ TEST(broadcast_gpu_int8_t, bs_fs_yx_bsv32_fsv32_1x128x4x5_to_2x256x4x5_w_b_axes_
}
TEST(broadcast_gpu_fp16, b_fs_yx_fsv16_1x128x4x5_to_2x256x4x5_w_b_axes_0) {
start_broadcast_test<FLOAT16>(format::b_fs_yx_fsv16, data_types::f16, {2, 256, 4, 5}, {1, 128, 4, 5}, {0});
start_broadcast_test<ov::float16>(format::b_fs_yx_fsv16, data_types::f16, {2, 256, 4, 5}, {1, 128, 4, 5}, {0});
}
TEST(broadcast_gpu_fp16, bs_fs_yx_bsv32_fsv16_1x128x4x5_to_2x256x4x5_w_b_axes_0) {
start_broadcast_test<FLOAT16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {2, 256, 4, 5}, {1, 128, 4, 5}, {0});
start_broadcast_test<ov::float16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {2, 256, 4, 5}, {1, 128, 4, 5}, {0});
}
@ -1817,11 +1817,11 @@ TEST(broadcast_gpu_int8_t, bs_fs_yx_bsv32_fsv32_2x4x5_to_2x3x4x5_w_b_axes_1) {
}
TEST(broadcast_gpu_fp16, b_fs_yx_fsv16_2x4x5_to_2x3x4x5_w_b_axes_1) {
start_broadcast_test<FLOAT16>(format::b_fs_yx_fsv16, data_types::f16, {2, 3, 4, 5}, {2, 4, 5}, {1});
start_broadcast_test<ov::float16>(format::b_fs_yx_fsv16, data_types::f16, {2, 3, 4, 5}, {2, 4, 5}, {1});
}
TEST(broadcast_gpu_fp16, bs_fs_yx_bsv32_fsv16_2x4x5_to_2x3x4x5_w_b_axes_1) {
start_broadcast_test<FLOAT16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {2, 3, 4, 5}, {2, 4, 5}, {1});
start_broadcast_test<ov::float16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {2, 3, 4, 5}, {2, 4, 5}, {1});
}
@ -1846,11 +1846,11 @@ TEST(broadcast_gpu_int8_t, bs_fs_yx_bsv32_fsv32_2x3x5_to_2x3x4x5_w_b_axes_2) {
}
TEST(broadcast_gpu_fp16, b_fs_yx_fsv16_2x3x5_to_2x3x4x5_w_b_axes_2) {
start_broadcast_test<FLOAT16>(format::b_fs_yx_fsv16, data_types::f16, {2, 3, 4, 5}, {2, 3, 5}, {2});
start_broadcast_test<ov::float16>(format::b_fs_yx_fsv16, data_types::f16, {2, 3, 4, 5}, {2, 3, 5}, {2});
}
TEST(broadcast_gpu_fp16, bs_fs_yx_bsv32_fsv16_2x3x5_to_2x3x4x5_w_b_axes_2) {
start_broadcast_test<FLOAT16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {2, 3, 4, 5}, {2, 3, 5}, {2});
start_broadcast_test<ov::float16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {2, 3, 4, 5}, {2, 3, 5}, {2});
}
@ -1875,11 +1875,11 @@ TEST(broadcast_gpu_int8_t, bs_fs_yx_bsv32_fsv32_2x3x4_to_2x3x4x5_w_b_axes_3) {
}
TEST(broadcast_gpu_fp16, b_fs_yx_fsv16_2x3x4_to_2x3x4x5_w_b_axes_3) {
start_broadcast_test<FLOAT16>(format::b_fs_yx_fsv16, data_types::f16, {2, 3, 4, 5}, {2, 3, 4}, {3});
start_broadcast_test<ov::float16>(format::b_fs_yx_fsv16, data_types::f16, {2, 3, 4, 5}, {2, 3, 4}, {3});
}
TEST(broadcast_gpu_fp16, bs_fs_yx_bsv32_fsv16_2x3x4_to_2x3x4x5_w_b_axes_3) {
start_broadcast_test<FLOAT16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {2, 3, 4, 5}, {2, 3, 4}, {3});
start_broadcast_test<ov::float16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {2, 3, 4, 5}, {2, 3, 4}, {3});
}
@ -1904,11 +1904,11 @@ TEST(broadcast_gpu_int8_t, bs_fs_yx_bsv32_fsv16_4x5_to_2x3x4x5_w_b_axes_0_1) {
}
TEST(broadcast_gpu_fp16, b_fs_yx_fsv16_4x5_to_2x3x4x5_w_b_axes_0_1) {
start_broadcast_test<FLOAT16>(format::b_fs_yx_fsv16, data_types::f16, {2, 3, 4, 5}, {4, 5}, {0, 1});
start_broadcast_test<ov::float16>(format::b_fs_yx_fsv16, data_types::f16, {2, 3, 4, 5}, {4, 5}, {0, 1});
}
TEST(broadcast_gpu_fp16, bs_fs_yx_bsv32_fsv16_4x5_to_2x3x4x5_w_b_axes_0_1) {
start_broadcast_test<FLOAT16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {2, 3, 4, 5}, {4, 5}, {0, 1});
start_broadcast_test<ov::float16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {2, 3, 4, 5}, {4, 5}, {0, 1});
}
@ -1933,11 +1933,11 @@ TEST(broadcast_gpu_int8_t, bs_fs_yx_bsv32_fsv32_3x5_to_2x3x4x5_w_b_axes_0_2) {
}
TEST(broadcast_gpu_fp16, b_fs_yx_fsv16_3x5_to_2x3x4x5_w_b_axes_0_2) {
start_broadcast_test<FLOAT16>(format::b_fs_yx_fsv16, data_types::f16, {2, 3, 4, 5}, {3, 5}, {0, 2});
start_broadcast_test<ov::float16>(format::b_fs_yx_fsv16, data_types::f16, {2, 3, 4, 5}, {3, 5}, {0, 2});
}
TEST(broadcast_gpu_fp16, bs_fs_yx_bsv32_fsv16_3x5_to_2x3x4x5_w_b_axes_0_2) {
start_broadcast_test<FLOAT16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {2, 3, 4, 5}, {3, 5}, {0, 2});
start_broadcast_test<ov::float16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {2, 3, 4, 5}, {3, 5}, {0, 2});
}
@ -1962,11 +1962,11 @@ TEST(broadcast_gpu_int8_t, bs_fs_yx_bsv32_fsv32_3x4_to_2x3x4x5_w_b_axes_0_3) {
}
TEST(broadcast_gpu_fp16, b_fs_yx_fsv16_3x4_to_2x3x4x5_w_b_axes_0_3) {
start_broadcast_test<FLOAT16>(format::b_fs_yx_fsv16, data_types::f16, {2, 3, 4, 5}, {3, 4}, {0, 3});
start_broadcast_test<ov::float16>(format::b_fs_yx_fsv16, data_types::f16, {2, 3, 4, 5}, {3, 4}, {0, 3});
}
TEST(broadcast_gpu_fp16, bs_fs_yx_bsv32_fsv16_3x4_to_2x3x4x5_w_b_axes_0_3) {
start_broadcast_test<FLOAT16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {2, 3, 4, 5}, {3, 4}, {0, 3});
start_broadcast_test<ov::float16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {2, 3, 4, 5}, {3, 4}, {0, 3});
}
@ -1991,11 +1991,11 @@ TEST(broadcast_gpu_int8_t, bs_fs_yx_bsv32_fsv32_2x5_to_2x3x4x5_w_b_axes_1_2) {
}
TEST(broadcast_gpu_fp16, b_fs_yx_fsv16_2x5_to_2x3x4x5_w_b_axes_1_2) {
start_broadcast_test<FLOAT16>(format::b_fs_yx_fsv16, data_types::f16, {2, 3, 4, 5}, {2, 5}, {1, 2});
start_broadcast_test<ov::float16>(format::b_fs_yx_fsv16, data_types::f16, {2, 3, 4, 5}, {2, 5}, {1, 2});
}
TEST(broadcast_gpu_fp16, bs_fs_yx_bsv32_fsv16_2x5_to_2x3x4x5_w_b_axes_1_2) {
start_broadcast_test<FLOAT16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {2, 3, 4, 5}, {2, 5}, {1, 2});
start_broadcast_test<ov::float16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {2, 3, 4, 5}, {2, 5}, {1, 2});
}
@ -2020,11 +2020,11 @@ TEST(broadcast_gpu_int8_t, bs_fs_yx_bsv32_fsv32_2x4_to_2x3x4x5_w_b_axes_1_3) {
}
TEST(broadcast_gpu_fp16, b_fs_yx_fsv16_2x4_to_2x3x4x5_w_b_axes_1_3) {
start_broadcast_test<FLOAT16>(format::b_fs_yx_fsv16, data_types::f16, {2, 3, 4, 5}, {2, 4}, {1, 3});
start_broadcast_test<ov::float16>(format::b_fs_yx_fsv16, data_types::f16, {2, 3, 4, 5}, {2, 4}, {1, 3});
}
TEST(broadcast_gpu_fp16, bs_fs_yx_bsv32_fsv16_2x4_to_2x3x4x5_w_b_axes_1_3) {
start_broadcast_test<FLOAT16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {2, 3, 4, 5}, {2, 4}, {1, 3});
start_broadcast_test<ov::float16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {2, 3, 4, 5}, {2, 4}, {1, 3});
}
@ -2049,11 +2049,11 @@ TEST(broadcast_gpu_int8_t, bs_fs_yx_bsv32_fsv32_2x3_to_2x3x4x5_w_b_axes_2_3) {
}
TEST(broadcast_gpu_fp16, b_fs_yx_fsv16_2x3_to_2x3x4x5_w_b_axes_2_3) {
start_broadcast_test<FLOAT16>(format::b_fs_yx_fsv16, data_types::f16, {2, 3, 4, 5}, {2, 3}, {2, 3});
start_broadcast_test<ov::float16>(format::b_fs_yx_fsv16, data_types::f16, {2, 3, 4, 5}, {2, 3}, {2, 3});
}
TEST(broadcast_gpu_fp16, bs_fs_yx_bsv32_fsv16_2x3_to_2x3x4x5_w_b_axes_2_3) {
start_broadcast_test<FLOAT16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {2, 3, 4, 5}, {2, 3}, {2, 3});
start_broadcast_test<ov::float16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {2, 3, 4, 5}, {2, 3}, {2, 3});
}
@ -2078,11 +2078,11 @@ TEST(broadcast_gpu_int8_t, bs_fs_yx_bsv32_fsv32_5_to_2x3x4x5_w_b_axes_0_1_2) {
}
TEST(broadcast_gpu_fp16, b_fs_yx_fsv16_5_to_2x3x4x5_w_b_axes_0_1_2) {
start_broadcast_test<FLOAT16>(format::b_fs_yx_fsv16, data_types::f16, {2, 3, 4, 5}, {5}, {0, 1, 2});
start_broadcast_test<ov::float16>(format::b_fs_yx_fsv16, data_types::f16, {2, 3, 4, 5}, {5}, {0, 1, 2});
}
TEST(broadcast_gpu_fp16, bs_fs_yx_bsv32_fsv16_5_to_2x3x4x5_w_b_axes_0_1_2) {
start_broadcast_test<FLOAT16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {2, 3, 4, 5}, {5}, {0, 1, 2});
start_broadcast_test<ov::float16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {2, 3, 4, 5}, {5}, {0, 1, 2});
}
@ -2107,11 +2107,11 @@ TEST(broadcast_gpu_int8_t, bs_fs_yx_bsv32_fsv32_4_to_2x3x4x5_w_b_axes_0_1_3) {
}
TEST(broadcast_gpu_fp16, b_fs_yx_fsv16_4_to_2x3x4x5_w_b_axes_0_1_3) {
start_broadcast_test<FLOAT16>(format::b_fs_yx_fsv16, data_types::f16, {2, 3, 4, 5}, {4}, {0, 1, 3});
start_broadcast_test<ov::float16>(format::b_fs_yx_fsv16, data_types::f16, {2, 3, 4, 5}, {4}, {0, 1, 3});
}
TEST(broadcast_gpu_fp16, bs_fs_yx_bsv32_fsv16_4_to_2x3x4x5_w_b_axes_0_1_3) {
start_broadcast_test<FLOAT16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {2, 3, 4, 5}, {4}, {0, 1, 3});
start_broadcast_test<ov::float16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {2, 3, 4, 5}, {4}, {0, 1, 3});
}
@ -2136,11 +2136,11 @@ TEST(broadcast_gpu_int8_t, bs_fs_yx_bsv32_fsv32_3_to_2x3x4x5_w_b_axes_0_2_3) {
}
TEST(broadcast_gpu_fp16, b_fs_yx_fsv16_3_to_2x3x4x5_w_b_axes_0_2_3) {
start_broadcast_test<FLOAT16>(format::b_fs_yx_fsv16, data_types::f16, {2, 3, 4, 5}, {3}, {0, 2, 3});
start_broadcast_test<ov::float16>(format::b_fs_yx_fsv16, data_types::f16, {2, 3, 4, 5}, {3}, {0, 2, 3});
}
TEST(broadcast_gpu_fp16, bs_fs_yx_bsv32_fsv16_3_to_2x3x4x5_w_b_axes_0_2_3) {
start_broadcast_test<FLOAT16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {2, 3, 4, 5}, {3}, {0, 2, 3});
start_broadcast_test<ov::float16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {2, 3, 4, 5}, {3}, {0, 2, 3});
}
@ -2165,11 +2165,11 @@ TEST(broadcast_gpu_int8_t, bs_fs_yx_bsv32_fsv32_2_to_2x3x4x5_w_b_axes_1_2_3) {
}
TEST(broadcast_gpu_fp16, b_fs_yx_fsv16_2_to_2x3x4x5_w_b_axes_1_2_3) {
start_broadcast_test<FLOAT16>(format::b_fs_yx_fsv16, data_types::f16, {2, 3, 4, 5}, {2}, {1, 2, 3});
start_broadcast_test<ov::float16>(format::b_fs_yx_fsv16, data_types::f16, {2, 3, 4, 5}, {2}, {1, 2, 3});
}
TEST(broadcast_gpu_fp16, bs_fs_yx_bsv32_fsv16_2_to_2x3x4x5_w_b_axes_1_2_3) {
start_broadcast_test<FLOAT16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {2, 3, 4, 5}, {2}, {1, 2, 3});
start_broadcast_test<ov::float16>(format::bs_fs_yx_bsv32_fsv16, data_types::f16, {2, 3, 4, 5}, {2}, {1, 2, 3});
}
@ -2186,7 +2186,7 @@ TEST(broadcast_gpu_int8_t, b_fs_zyx_fsv32_1x48x1x1_to_1x48x1x5_w_b_axes_0) {
}
TEST(broadcast_gpu_fp16, b_fs_zyx_fsv16_1x48x1x1_to_1x48x1x5_w_b_axes_0) {
start_broadcast_test_5d<FLOAT16>(format::b_fs_zyx_fsv16, data_types::f16, { 1, 48, 1, 5 }, { 1, 48, 1, 1 }, { 0 });
start_broadcast_test_5d<ov::float16>(format::b_fs_zyx_fsv16, data_types::f16, { 1, 48, 1, 5 }, { 1, 48, 1, 1 }, { 0 });
}
@ -2203,7 +2203,7 @@ TEST(broadcast_gpu_int8_t, b_fs_zyx_fsv32_64x256x2x1_to_128x256x4x5_w_b_axes_0x1
}
TEST(broadcast_gpu_fp16, b_fs_zyx_fsv16_64x256x2x1_to_128x256x4x5_w_b_axes_0x1) {
start_broadcast_test_5d<FLOAT16>(format::b_fs_zyx_fsv16, data_types::f16, { 128, 256, 4, 5 }, { 64, 256, 2, 1}, {});
start_broadcast_test_5d<ov::float16>(format::b_fs_zyx_fsv16, data_types::f16, { 128, 256, 4, 5 }, { 64, 256, 2, 1}, {});
}
@ -2220,7 +2220,7 @@ TEST(broadcast_gpu_int8_t, b_fs_zyx_fsv32_1_to_4x5_w_b_axes_0x1) {
}
TEST(broadcast_gpu_fp16, b_fs_zyx_fsv16_1_to_4x5_w_b_axes_0x1) {
start_broadcast_test_5d<FLOAT16>(format::b_fs_zyx_fsv16, data_types::f16, { 4, 5 }, { 1 }, { 0, 1 });
start_broadcast_test_5d<ov::float16>(format::b_fs_zyx_fsv16, data_types::f16, { 4, 5 }, { 1 }, { 0, 1 });
}
@ -2237,9 +2237,9 @@ TEST(broadcast_gpu_int8_t, b_fs_zyx_fsv32_1_to_2x3x4x5x2_w_b_axes_0x1x2x3x4) {
}
TEST(broadcast_gpu_fp16, b_fs_zyx_fsv16_1_to_2x3x4x5x2_w_b_axes_0x1x2x3x4) {
start_broadcast_test_5d<FLOAT16>(format::b_fs_zyx_fsv16, data_types::f16, { 2, 3, 4, 5, 2 }, { 1 }, { 0, 1, 2, 3, 4 });
start_broadcast_test_5d<ov::float16>(format::b_fs_zyx_fsv16, data_types::f16, { 2, 3, 4, 5, 2 }, { 1 }, { 0, 1, 2, 3, 4 });
}
TEST(export_import_broadcast_gpu_fp16, b_fs_zyx_fsv16_1_to_2x3x4x5x2_w_b_axes_0x1x2x3x4) {
start_broadcast_test_5d<FLOAT16>(format::b_fs_zyx_fsv16, data_types::f16, { 2, 3, 4, 5, 2 }, { 1 }, { 0, 1, 2, 3, 4 }, true);
start_broadcast_test_5d<ov::float16>(format::b_fs_zyx_fsv16, data_types::f16, { 2, 3, 4, 5, 2 }, { 1 }, { 0, 1, 2, 3, 4 }, true);
}

35
src/plugins/intel_gpu/tests/unit/test_cases/bucketize_gpu_test.cpp
View File

@ -32,13 +32,13 @@ struct bucketize_test : testing::TestWithParam<bucketize_test_params<I, B, O>> {
std::tie(p, fmt, is_caching_test) = testing::TestWithParam<bucketize_test_params<I, B, O>>::GetParam();
auto& engine = get_test_engine();
const layout in_layout(type_to_data_type<I>::value,
const layout in_layout(ov::element::from<I>(),
format::bfyx,
tensor(format::bfyx, {1, 1, 1, static_cast<int>(p.input_values.size())}));
auto input = engine.allocate_memory(in_layout);
set_values(input, p.input_values);
const layout buckets_layout(type_to_data_type<B>::value,
const layout buckets_layout(ov::element::from<B>(),
format::bfyx,
tensor(format::bfyx, {static_cast<int>(p.buckets_values.size()), 1, 1, 1}));
auto buckets = engine.allocate_memory(buckets_layout);
@ -47,17 +47,17 @@ struct bucketize_test : testing::TestWithParam<bucketize_test_params<I, B, O>> {
topology topology;
topology.add(input_layout("input", input->get_layout()));
topology.add(input_layout("buckets", buckets->get_layout()));
topology.add(reorder("reordered_input", input_info("input"), fmt, type_to_data_type<I>::value));
topology.add(reorder("reordered_buckets", input_info("buckets"), fmt, type_to_data_type<B>::value));
topology.add(reorder("reordered_input", input_info("input"), fmt, ov::element::from<I>()));
topology.add(reorder("reordered_buckets", input_info("buckets"), fmt, ov::element::from<B>()));
topology.add(
bucketize("bucketize_right_bound", { input_info("reordered_input"), input_info("buckets") }, type_to_data_type<O>::value, true));
bucketize("bucketize_right_bound", { input_info("reordered_input"), input_info("buckets") }, ov::element::from<O>(), true));
topology.add(
bucketize("bucketize_left_bound", { input_info("reordered_input"), input_info("buckets") }, type_to_data_type<O>::value, false));
bucketize("bucketize_left_bound", { input_info("reordered_input"), input_info("buckets") }, ov::element::from<O>(), false));
topology.add(
reorder("plane_bucketize_right_bound", input_info("bucketize_right_bound"), format::bfyx, type_to_data_type<O>::value));
reorder("plane_bucketize_right_bound", input_info("bucketize_right_bound"), format::bfyx, ov::element::from<O>()));
topology.add(
reorder("plane_bucketize_left_bound", input_info("bucketize_left_bound"), format::bfyx, type_to_data_type<O>::value));
reorder("plane_bucketize_left_bound", input_info("bucketize_left_bound"), format::bfyx, ov::element::from<O>()));
cldnn::network::ptr network = get_network(engine, topology, get_test_default_config(engine), get_test_stream_ptr(), is_caching_test);
@ -86,9 +86,9 @@ struct bucketize_test : testing::TestWithParam<bucketize_test_params<I, B, O>> {
static std::string PrintToStringParamName(const testing::TestParamInfo<bucketize_test_params<I, B, O>>& info) {
std::ostringstream result;
result << "inType=" << data_type_traits::name(type_to_data_type<I>::value) << "_";
result << "bucketsType=" << data_type_traits::name(type_to_data_type<B>::value) << "_";
result << "outType=" << data_type_traits::name(type_to_data_type<O>::value) << "_";
result << "inType=" << ov::element::Type(ov::element::from<I>()) << "_";
result << "bucketsType=" << ov::element::Type(ov::element::from<B>()) << "_";
result << "outType=" << ov::element::Type(ov::element::from<O>()) << "_";
result << "format=" << std::get<1>(info.param);
result << "is_caching_test=" << std::get<2>(info.param);
return result.str();
@ -140,16 +140,17 @@ INSTANTIATE_BUCKETIZE_TEST_SUITE(int32_t, uint8_t, int32_t, getBucketizeParams)
INSTANTIATE_BUCKETIZE_TEST_SUITE(int64_t, int8_t, int64_t, getBucketizeParams)
INSTANTIATE_BUCKETIZE_TEST_SUITE(int64_t, int32_t, int32_t, getBucketizeParams)
INSTANTIATE_BUCKETIZE_TEST_SUITE(float, FLOAT16, int64_t, getBucketizeFloatingPointParams)
INSTANTIATE_BUCKETIZE_TEST_SUITE(FLOAT16, float, int32_t, getBucketizeFloatingPointParams)
using ov::float16;
INSTANTIATE_BUCKETIZE_TEST_SUITE(float, float16, int64_t, getBucketizeFloatingPointParams)
INSTANTIATE_BUCKETIZE_TEST_SUITE(float16, float, int32_t, getBucketizeFloatingPointParams)
INSTANTIATE_BUCKETIZE_TEST_SUITE(float, float, int64_t, getBucketizeFloatingPointParams)
INSTANTIATE_BUCKETIZE_TEST_SUITE(FLOAT16, FLOAT16, int32_t, getBucketizeFloatingPointParams)
INSTANTIATE_BUCKETIZE_TEST_SUITE(float16, float16, int32_t, getBucketizeFloatingPointParams)
INSTANTIATE_TEST_SUITE_P(export_import,
bucketize_test_FLOAT16FLOAT16int32_t,
testing::Combine(testing::ValuesIn(getBucketizeFloatingPointParams<FLOAT16, FLOAT16, int32_t>()),
bucketize_test_float16float16int32_t,
testing::Combine(testing::ValuesIn(getBucketizeFloatingPointParams<ov::float16, ov::float16, int32_t>()),
testing::Values(layout_formats[0]),
testing::Values(true)),
bucketize_test_FLOAT16FLOAT16int32_t::PrintToStringParamName);
bucketize_test_float16float16int32_t::PrintToStringParamName);
#undef INSTANTIATE_BUCKETIZE_TEST_SUITE

64
src/plugins/intel_gpu/tests/unit/test_cases/concatenation_gpu_test.cpp
View File

@ -35,10 +35,10 @@ TEST(concat_gpu, mixed_input_types) {
set_values<float>(input0, { 1.0f, 2.0f, 3.0f, 4.0f, 2.0f, 2.0f, 3.0f, 4.0f, 3.0f, 3.0f, 3.0f, 5.0f });
set_values<int32_t>(input1, { 11, 12, 13, 14, 12, 12, 13, 14, 13, 13, 13, 15 });
set_values<int8_t>(input2, { 21, 22, 23, 24, 22, 22, 23, 24, 23, 23, 23, 25 });
set_values(input3, { half_t(31.f), half_t(32.f), half_t(33.f),
half_t(34.f), half_t(32.f), half_t(32.f),
half_t(33.f), half_t(34.f), half_t(33.f),
half_t(33.f), half_t(33.f), half_t(35.f) });
set_values(input3, { ov::float16(31.f), ov::float16(32.f), ov::float16(33.f),
ov::float16(34.f), ov::float16(32.f), ov::float16(32.f),
ov::float16(33.f), ov::float16(34.f), ov::float16(33.f),
ov::float16(33.f), ov::float16(33.f), ov::float16(35.f) });
set_values<int64_t>(input4, { 41, 42, 43, 44, 42, 42, 43, 44, 43, 43, 43, 45 });
VF<float> output_vec = {
@ -315,22 +315,22 @@ TEST(concat_gpu, mixed_input_types_5d) {
auto input2 = engine.allocate_memory({ data_types::f16, format::bfzyx, { 1, 1, 1, 4, 3 } });
auto input3 = engine.allocate_memory({ data_types::f16, format::bfzyx, { 1, 1, 1, 4, 3 } });
set_values(input0, { half_t(1.0f), half_t(2.0f), half_t(3.0f),
half_t(4.0f), half_t(2.0f), half_t(2.0f),
half_t(3.0f), half_t(4.0f), half_t(3.0f),
half_t(3.0f), half_t(3.0f), half_t(5.0f) });
set_values(input1, { half_t(11), half_t(12), half_t(13),
half_t(14), half_t(12), half_t(12),
half_t(13), half_t(14), half_t(13),
half_t(13), half_t(13), half_t(15) });
set_values(input2, { half_t(21), half_t(22), half_t(23),
half_t(24), half_t(22), half_t(22),
half_t(23), half_t(24), half_t(23),
half_t(23), half_t(23), half_t(25) });
set_values(input3, { half_t(31.f), half_t(32.f), half_t(33.f),
half_t(34.f), half_t(32.f), half_t(32.f),
half_t(33.f), half_t(34.f), half_t(33.f),
half_t(33.f), half_t(33.f), half_t(35.f) });
set_values(input0, { ov::float16(1.0f), ov::float16(2.0f), ov::float16(3.0f),
ov::float16(4.0f), ov::float16(2.0f), ov::float16(2.0f),
ov::float16(3.0f), ov::float16(4.0f), ov::float16(3.0f),
ov::float16(3.0f), ov::float16(3.0f), ov::float16(5.0f) });
set_values(input1, { ov::float16(11), ov::float16(12), ov::float16(13),
ov::float16(14), ov::float16(12), ov::float16(12),
ov::float16(13), ov::float16(14), ov::float16(13),
ov::float16(13), ov::float16(13), ov::float16(15) });
set_values(input2, { ov::float16(21), ov::float16(22), ov::float16(23),
ov::float16(24), ov::float16(22), ov::float16(22),
ov::float16(23), ov::float16(24), ov::float16(23),
ov::float16(23), ov::float16(23), ov::float16(25) });
set_values(input3, { ov::float16(31.f), ov::float16(32.f), ov::float16(33.f),
ov::float16(34.f), ov::float16(32.f), ov::float16(32.f),
ov::float16(33.f), ov::float16(34.f), ov::float16(33.f),
ov::float16(33.f), ov::float16(33.f), ov::float16(35.f) });
VF<float> output_vec = {
1.0f, 2.0f, 3.0f, 4.0f, 2.0f, 2.0f, 3.0f, 4.0f, 3.0f, 3.0f, 3.0f, 5.0f,
@ -825,7 +825,7 @@ struct concat_gpu_4d : public concat_gpu {
public:
void test(format::type fmt) {
auto data_type = type_to_data_type<Type>::value;
auto data_type = ov::element::from<Type>();
auto& engine = get_test_engine();
const size_t batch_num = testing::get<0>(GetParam());
@ -911,7 +911,7 @@ struct concat_gpu_4d_axis3 : public concat_axis3_gpu {
public:
void test(format::type fmt) {
auto data_type = type_to_data_type<Type>::value;
auto data_type = ov::element::from<Type>();
auto& engine = get_test_engine();
const size_t batch_num = testing::get<0>(GetParam());
@ -992,7 +992,7 @@ public:
};
using concat_gpu_4d_f16 = concat_gpu_4d<FLOAT16>;
using concat_gpu_4d_f16 = concat_gpu_4d<ov::float16>;
using concat_gpu_4d_i8 = concat_gpu_4d<int8_t>;
using concat_gpu_4d_u8 = concat_gpu_4d<uint8_t>;
@ -1027,7 +1027,7 @@ INSTANTIATE_TEST_SUITE_P(smoke_low_precision,
concat_gpu_all_params,
concat_gpu::PrintToStringParamName);
using concat_gpu_4d_axis3_f16 = concat_gpu_4d_axis3<FLOAT16>;
using concat_gpu_4d_axis3_f16 = concat_gpu_4d_axis3<ov::float16>;
TEST_P(concat_gpu_4d_axis3_f16, fs_b_yx_fsv32) {
ASSERT_NO_FATAL_FAILURE(test(format::fs_b_yx_fsv32));
@ -1056,7 +1056,7 @@ struct concat_id_conv_gpu_4d : public concat_gpu {
public:
void test(format::type fmt) {
auto data_type = type_to_data_type<Type>::value;
auto data_type = ov::element::from<Type>();
auto& engine = get_test_engine();
const size_t batch_num = testing::get<0>(GetParam());
@ -1158,7 +1158,7 @@ public:
}
};
using concat_id_conv_gpu_4d_f16 = concat_id_conv_gpu_4d<FLOAT16, FLOAT16>;
using concat_id_conv_gpu_4d_f16 = concat_id_conv_gpu_4d<ov::float16, ov::float16>;
using concat_id_conv_gpu_4d_i8 = concat_id_conv_gpu_4d<int8_t, float>;
TEST_P(concat_id_conv_gpu_4d_f16, input_order_opt_b_fs_yx_fsv16) {
@ -1195,7 +1195,7 @@ template <typename Type>
struct concat_gpu_4d_implicit : public concat_gpu {
public:
cldnn::memory::ptr run_concat_network(std::vector<std::vector<std::vector<std::vector<std::vector<Type>>>>> input, format::type fmt, ExecutionConfig config) {
auto data_type = type_to_data_type<Type>::value;
auto data_type = ov::element::from<Type>();
auto& engine = get_test_engine();
const size_t batch_num = testing::get<0>(GetParam());
const std::vector<size_t> in_features = testing::get<1>(GetParam());
@ -1313,7 +1313,7 @@ public:
}
};
using concat_implicit_gpu_4d_f16 = concat_gpu_4d_implicit<FLOAT16>;
using concat_implicit_gpu_4d_f16 = concat_gpu_4d_implicit<ov::float16>;
using concat_implicit_gpu_4d_i8 = concat_gpu_4d_implicit<int8_t>;
TEST_P(concat_implicit_gpu_4d_f16, input_order_opt_b_fs_yx_fsv16) {
@ -1417,7 +1417,7 @@ template <typename Type>
struct concat_gpu_4d_implicit_onednn : public concat_gpu {
public:
cldnn::memory::ptr run_concat_network(std::vector<std::vector<std::vector<std::vector<std::vector<Type>>>>> input, format::type fmt, ExecutionConfig config) {
auto data_type = type_to_data_type<Type>::value;
auto data_type = ov::element::from<Type>();
auto& engine = get_test_engine();
const size_t batch_num = testing::get<0>(GetParam());
const std::vector<size_t> in_features = testing::get<1>(GetParam());
@ -1544,7 +1544,7 @@ public:
};
using concat_implicit_gpu_onednn_4d_f16 = concat_gpu_4d_implicit_onednn<FLOAT16>;
using concat_implicit_gpu_onednn_4d_f16 = concat_gpu_4d_implicit_onednn<ov::float16>;
using concat_implicit_gpu_onednn_4d_i8 = concat_gpu_4d_implicit_onednn<int8_t>;
TEST_P(concat_implicit_gpu_onednn_4d_f16, input_order_opt_b_fs_yx_fsv16) {
@ -1577,7 +1577,7 @@ template <typename Type>
struct concat_gpu_4d_explict : public concat_gpu {
public:
cldnn::memory::ptr run_concat_network(std::vector<std::vector<std::vector<std::vector<std::vector<Type>>>>> input, format::type fmt, ExecutionConfig config) {
auto data_type = type_to_data_type<Type>::value;
auto data_type = ov::element::from<Type>();
auto& engine = get_test_engine();
const size_t batch_num = testing::get<0>(GetParam());
const std::vector<size_t> in_features = testing::get<1>(GetParam()); // only use first element.
@ -1711,7 +1711,7 @@ public:
};
using concat_no_implicit_gpu_onednn_4d_f16 = concat_gpu_4d_explict<FLOAT16>;
using concat_no_implicit_gpu_onednn_4d_f16 = concat_gpu_4d_explict<ov::float16>;
TEST_P(concat_no_implicit_gpu_onednn_4d_f16, input_order_opt_b_fs_yx_fsv16) {
ASSERT_NO_FATAL_FAILURE(test(format::b_fs_yx_fsv16));

5
src/plugins/intel_gpu/tests/unit/test_cases/condition_gpu_test.cpp
View File

@ -49,7 +49,6 @@ topology generate_simple_branch (bool branch_true_false, const primitive_id& id,
template < typename DataType>
struct condition_data_types {
using type = DataType;
static const data_types data_type = type_to_data_type<DataType>::value;
};
template <typename ConditionDataType>
@ -69,7 +68,7 @@ public:
void run_test() {
auto& engine = get_test_engine();
auto dat_dt = ConditionDataType::data_type;
auto dat_dt = static_cast<ov::element::Type>(ov::element::from<typename ConditionDataType::type>());
ExecutionConfig config = get_test_default_config(engine);
config.set_property(ov::intel_gpu::optimize_data(true));
@ -140,7 +139,7 @@ public:
}
};
using test_data_types = testing::Types<condition_data_types<FLOAT16>,
using test_data_types = testing::Types<condition_data_types<ov::float16>,
condition_data_types<float>>;
TYPED_TEST_SUITE(condition_gpu_basic_test, test_data_types);

6
src/plugins/intel_gpu/tests/unit/test_cases/convert_color_gpu_test.cpp
View File

@ -194,8 +194,8 @@ TEST(convert_color, nv12_to_rgb_two_planes_buffer_fp16) {
auto input_y = engine.allocate_memory({ { 1, height, width, 1 }, data_types::f16, format::bfyx });
auto input_uv = engine.allocate_memory({ { 1, height / 2 , width / 2, 2 }, data_types::f16, format::bfyx});
std::vector<FLOAT16> input_y_data = rg.generate_random_1d<FLOAT16>(width * height, 0, 255);
std::vector<FLOAT16> input_uv_data = rg.generate_random_1d<FLOAT16>(width * height / 2, 0, 255);
std::vector<ov::float16> input_y_data = rg.generate_random_1d<ov::float16>(width * height, 0, 255);
std::vector<ov::float16> input_uv_data = rg.generate_random_1d<ov::float16>(width * height / 2, 0, 255);
set_values(input_y, input_y_data);
set_values(input_uv, input_uv_data);
@ -216,7 +216,7 @@ TEST(convert_color, nv12_to_rgb_two_planes_buffer_fp16) {
auto outputs = network.execute();
std::vector<float> ref_res(width * height * 3);
createReferenceDataNV12<FLOAT16, float>(input_y_data.data(), input_uv_data.data(), ref_res.data(),
createReferenceDataNV12<ov::float16, float>(input_y_data.data(), input_uv_data.data(), ref_res.data(),
1, height, width, height * width, height * width / 2, true);
auto output = outputs.at("convert_color").get_memory();

156
src/plugins/intel_gpu/tests/unit/test_cases/convolution_gpu_test.cpp
View File

@ -5067,19 +5067,19 @@ TEST_P(convolution_gpu_fs_byx_fsv32, fs_byx_fsv32)
const int output_xy = 1 + (input_xy + 2 * pad - filter_xy) / stride + 2 * output_padding;
auto input_size = tensor(batch_num, input_f, input_xy, input_xy);
auto input_data = rg.generate_random_4d<FLOAT16>(batch_num, input_f, input_xy, input_xy, -1, 1);
auto input_data = rg.generate_random_4d<ov::float16>(batch_num, input_f, input_xy, input_xy, -1, 1);
auto input_data_bfyx = flatten_4d(format::bfyx, input_data);
auto input_mem = engine.allocate_memory({ data_types::f16, format::bfyx, input_size });
set_values(input_mem, input_data_bfyx);
auto weights_size = tensor(output_f, input_f, filter_xy, filter_xy);
auto weights_data = rg.generate_random_4d<FLOAT16>(output_f, input_f, filter_xy, filter_xy, -1, 1);
auto weights_data = rg.generate_random_4d<ov::float16>(output_f, input_f, filter_xy, filter_xy, -1, 1);
auto weights_data_bfyx = flatten_4d(format::bfyx, weights_data);
auto weights_mem = engine.allocate_memory({ data_types::f16, format::bfyx, weights_size });
set_values(weights_mem, weights_data_bfyx);
// Will be used to store reference values calculated in branches depending on bias
auto reference_result = VVVVF<FLOAT16>(batch_num, VVVF<FLOAT16>(output_f));
auto reference_result = VVVVF<ov::float16>(batch_num, VVVF<ov::float16>(output_f));
topology topology(
input_layout("input", input_mem->get_layout()),
@ -5092,7 +5092,7 @@ TEST_P(convolution_gpu_fs_byx_fsv32, fs_byx_fsv32)
{
// Generate bias data
auto biases_size = tensor(1, output_f, 1, 1);
auto biases_data = rg.generate_random_1d<FLOAT16>(output_f, -1, 1);
auto biases_data = rg.generate_random_1d<ov::float16>(output_f, -1, 1);
auto biases_mem = engine.allocate_memory({ data_types::f16, format::bfyx, biases_size });
set_values(biases_mem, biases_data);
@ -5171,7 +5171,7 @@ TEST_P(convolution_gpu_fs_byx_fsv32, fs_byx_fsv32)
network.execute();
auto out_mem = network.get_output("conv_fsv").get_memory();
cldnn::mem_lock<FLOAT16> out_ptr(out_mem, get_test_stream());
cldnn::mem_lock<ov::float16> out_ptr(out_mem, get_test_stream());
ASSERT_EQ(out_mem->get_layout().format, format::fs_b_yx_fsv32);
@ -5214,19 +5214,19 @@ TEST(convolution_f16_fsv_gpu, convolution_f16_fsv_gpu_padding) {
const int output_xy = 1 + (input_xy - filter_xy) / stride;
auto input_size = tensor(batch_num, input_f, input_xy, input_xy);
auto input_data = rg.generate_random_4d<FLOAT16>(batch_num, input_f, input_xy, input_xy, -1, 1);
auto input_data = rg.generate_random_4d<ov::float16>(batch_num, input_f, input_xy, input_xy, -1, 1);
auto input_data_bfyx = flatten_4d(format::bfyx, input_data);
auto input_mem = engine.allocate_memory({ data_types::f16, format::bfyx, input_size });
set_values(input_mem, input_data_bfyx);
auto weights_size = tensor(output_f, input_f, filter_xy, filter_xy);
auto weights_data = rg.generate_random_4d<FLOAT16>(output_f, input_f, filter_xy, filter_xy, -1, 1);
auto weights_data = rg.generate_random_4d<ov::float16>(output_f, input_f, filter_xy, filter_xy, -1, 1);
auto weights_data_bfyx = flatten_4d(format::bfyx, weights_data);
auto weights_mem = engine.allocate_memory({ data_types::f16, format::bfyx, weights_size });
set_values(weights_mem, weights_data_bfyx);
// Will be used to store reference values calculated in branches depending on bias
auto reference_result = VVVVF<FLOAT16>(batch_num, VVVF<FLOAT16>(output_f));
auto reference_result = VVVVF<ov::float16>(batch_num, VVVF<ov::float16>(output_f));
topology topology(
input_layout("input", input_mem->get_layout()),
@ -5238,7 +5238,7 @@ TEST(convolution_f16_fsv_gpu, convolution_f16_fsv_gpu_padding) {
// Generate bias data
auto biases_size = tensor(1, output_f, 1, 1);
auto biases_data = rg.generate_random_1d<FLOAT16>(output_f, -1, 1);
auto biases_data = rg.generate_random_1d<ov::float16>(output_f, -1, 1);
auto biases_mem = engine.allocate_memory({ data_types::f16, format::bfyx, biases_size });
set_values(biases_mem, biases_data);
@ -5281,7 +5281,7 @@ TEST(convolution_f16_fsv_gpu, convolution_f16_fsv_gpu_padding) {
network.execute();
auto out_mem = network.get_output("conv_fsv").get_memory();
cldnn::mem_lock<FLOAT16> out_ptr(out_mem, get_test_stream());
cldnn::mem_lock<ov::float16> out_ptr(out_mem, get_test_stream());
ASSERT_EQ(out_mem->get_layout().format, format::fs_b_yx_fsv32);
@ -5358,14 +5358,14 @@ TEST_P(convolution_gpu_fs_byx_fsv32_crop, fs_byx_fsv32_crop)
const int output_xy = 1 + (input_xy + 2 * pad - filter_xy) / stride + 2 * output_padding;
auto weights_size = tensor(output_f, input_f, filter_xy, filter_xy);
auto weights_data = rg.generate_random_4d<FLOAT16>(output_f, input_f, filter_xy, filter_xy, -1, 1);
auto weights_data = rg.generate_random_4d<ov::float16>(output_f, input_f, filter_xy, filter_xy, -1, 1);
auto weights_data_bfyx = flatten_4d(format::bfyx, weights_data);
auto weights_mem = engine.allocate_memory({ data_types::f16, format::bfyx, weights_size });
set_values(weights_mem, weights_data_bfyx);
// ref input
auto half_input_data = rg.generate_random_4d<FLOAT16>(batch_num, input_f, input_xy, input_xy, -1, 1);
auto input_data = VVVVF<FLOAT16>(batch_num);
auto half_input_data = rg.generate_random_4d<ov::float16>(batch_num, input_f, input_xy, input_xy, -1, 1);
auto input_data = VVVVF<ov::float16>(batch_num);
// concatenated cldnn input tensor
for (auto bi = 0; bi < batch_num; ++bi)
@ -5402,14 +5402,14 @@ TEST_P(convolution_gpu_fs_byx_fsv32_crop, fs_byx_fsv32_crop)
topology.add(right_crop);
// Will be used to store reference values calculated in branches depending on bias
auto half_ref_result = VVVVF<FLOAT16>(batch_num, VVVF<FLOAT16>(output_f));
auto half_ref_result = VVVVF<ov::float16>(batch_num, VVVF<ov::float16>(output_f));
// reference convolution and concat
if (with_bias)
{
// Generate bias data
auto biases_size = tensor(1, output_f, 1, 1);
auto biases_data = rg.generate_random_1d<FLOAT16>(output_f, -1, 1);
auto biases_data = rg.generate_random_1d<ov::float16>(output_f, -1, 1);
auto biases_mem = engine.allocate_memory({ data_types::f16, format::bfyx, biases_size });
set_values(biases_mem, biases_data);
@ -5478,7 +5478,7 @@ TEST_P(convolution_gpu_fs_byx_fsv32_crop, fs_byx_fsv32_crop)
topology.add(reorder("reorder", input_info("conv_fsv"), { data_types::f16, format::bfyx, input_size }));
topology.add(concatenation("concat", { input_info("left_crop"), input_info("reorder") }, 1));
auto ref_result = VVVVF<FLOAT16>(batch_num);
auto ref_result = VVVVF<ov::float16>(batch_num);
// concatenate half ref input and ref conv output, by features
for (auto bi = 0; bi < batch_num; ++bi)
{
@ -5505,7 +5505,7 @@ TEST_P(convolution_gpu_fs_byx_fsv32_crop, fs_byx_fsv32_crop)
network.execute();
auto out_mem = network.get_output("concat").get_memory();
cldnn::mem_lock<FLOAT16> out_ptr(out_mem, get_test_stream());
cldnn::mem_lock<ov::float16> out_ptr(out_mem, get_test_stream());
ASSERT_EQ(out_mem->get_layout().format, format::bfyx);
@ -5660,21 +5660,21 @@ TEST(convolution_gpu, bfyx_iyxo_5x5_fp16)
const int output_y = 1 + (input_size_y + 2 * pad - filter_xy) / stride + 2 * output_padding;
auto input_size = tensor(batch_num, input_f, input_size_x, input_size_y);
auto input_data = rg.generate_random_4d<FLOAT16>(batch_num, input_f, input_size_y, input_size_x, -1, 1);
auto input_data = rg.generate_random_4d<ov::float16>(batch_num, input_f, input_size_y, input_size_x, -1, 1);
auto input_data_bfyx = flatten_4d(format::bfyx, input_data);
auto input_mem = engine.allocate_memory({ data_types::f16, format::bfyx, input_size });
set_values(input_mem, input_data_bfyx);
auto weights_size = tensor(output_f, input_f, filter_xy, filter_xy);
auto weights_data = rg.generate_random_4d<FLOAT16>(output_f, input_f, filter_xy, filter_xy, -1, 1);
auto weights_data = rg.generate_random_4d<ov::float16>(output_f, input_f, filter_xy, filter_xy, -1, 1);
auto weights_data_bfyx = flatten_4d(format::bfyx, weights_data);
auto weights_mem = engine.allocate_memory({ data_types::f16, format::bfyx, weights_size });
set_values(weights_mem, weights_data_bfyx);
// Will be used to store reference values calculated in branches depending on bias
auto reference_result = VVVVF<FLOAT16>(batch_num, VVVF<FLOAT16>(output_f));
auto reference_result = VVVVF<ov::float16>(batch_num, VVVF<ov::float16>(output_f));
topology topology(
input_layout("input", input_mem->get_layout()),
@ -5685,7 +5685,7 @@ TEST(convolution_gpu, bfyx_iyxo_5x5_fp16)
{
// Generate bias data
auto biases_size = tensor(1, output_f, 1, 1);
auto biases_data = rg.generate_random_1d<FLOAT16>(output_f, -1, 1);
auto biases_data = rg.generate_random_1d<ov::float16>(output_f, -1, 1);
auto biases_mem = engine.allocate_memory({ data_types::f16, format::bfyx, biases_size });
set_values(biases_mem, biases_data);
@ -5749,7 +5749,7 @@ TEST(convolution_gpu, bfyx_iyxo_5x5_fp16)
network.execute();
auto out_mem = network.get_output("out").get_memory();
cldnn::mem_lock<FLOAT16> out_ptr(out_mem, get_test_stream());
cldnn::mem_lock<ov::float16> out_ptr(out_mem, get_test_stream());
auto output_layout = out_mem->get_layout();
ASSERT_EQ(output_layout.format, format::bfyx);
@ -6028,14 +6028,14 @@ TEST_P(convolution_gpu_block_layout3D, bfzyx_bsv16_fsv16_fp16)
input_format = format::bs_fs_zyx_bsv16_fsv16;
auto input_size = tensor(batch_num, input_f, input_xy, input_xy, 1);
auto input_data = rg.generate_random_4d<FLOAT16>(batch_num, input_f, input_xy, input_xy, 0, 1);
auto input_data = rg.generate_random_4d<ov::float16>(batch_num, input_f, input_xy, input_xy, 0, 1);
auto input_data_bfyx = flatten_4d(format::bfyx, input_data);
auto input_mem = engine.allocate_memory({ data_types::f16, format::bfzyx, input_size });
set_values(input_mem, input_data_bfyx);
auto weights_size = tensor(output_f, input_f, filter_xy, filter_xy, 1);
auto weights_data = rg.generate_random_4d<FLOAT16>(output_f, input_f, filter_xy, filter_xy, 0, 1);
auto weights_data = rg.generate_random_4d<ov::float16>(output_f, input_f, filter_xy, filter_xy, 0, 1);
auto weights_data_bfyx = flatten_4d(format::bfyx, weights_data);
@ -6043,7 +6043,7 @@ TEST_P(convolution_gpu_block_layout3D, bfzyx_bsv16_fsv16_fp16)
set_values(weights_mem, weights_data_bfyx);
// Will be used to store reference values calculated in branches depending on bias
auto reference_result = VVVVF<FLOAT16>(batch_num, VVVF<FLOAT16>(output_f));
auto reference_result = VVVVF<ov::float16>(batch_num, VVVF<ov::float16>(output_f));
topology topology(
input_layout("input", input_mem->get_layout()),
@ -6056,7 +6056,7 @@ TEST_P(convolution_gpu_block_layout3D, bfzyx_bsv16_fsv16_fp16)
{
// Generate bias data
auto biases_size = tensor(1, output_f, 1, 1, 1);
auto biases_data = rg.generate_random_1d<FLOAT16>(output_f, -1, 1);
auto biases_data = rg.generate_random_1d<ov::float16>(output_f, -1, 1);
auto biases_mem = engine.allocate_memory({ data_types::f16, format::bfzyx, biases_size });
set_values(biases_mem, biases_data);
@ -6120,12 +6120,12 @@ TEST_P(convolution_gpu_block_layout3D, bfzyx_bsv16_fsv16_fp16)
network.execute();
auto out_mem = network.get_output("conv_bsv16_fsv16").get_memory();
cldnn::mem_lock<FLOAT16> out_ptr(out_mem, get_test_stream());
cldnn::mem_lock<ov::float16> out_ptr(out_mem, get_test_stream());
auto out_mem_bfyx = network.get_output("reorder_bfzyx").get_memory();
cldnn::mem_lock<FLOAT16> out_ptr_bfyx(out_mem_bfyx, get_test_stream());
cldnn::mem_lock<ov::float16> out_ptr_bfyx(out_mem_bfyx, get_test_stream());
blockedFormatZeroCheck<FLOAT16>(out_mem);
blockedFormatZeroCheck<ov::float16>(out_mem);
ASSERT_EQ(out_mem->get_layout().format, input_format);
@ -6470,14 +6470,14 @@ TEST_P(convolution_gpu_block_layout, bfyx_bsv16_fsv16_fp16)
tests::random_generator rg(GET_SUITE_NAME);
auto input_size = tensor(batch_num, input_f, input_xy, input_xy);
auto input_data = rg.generate_random_4d<FLOAT16>(batch_num, input_f, input_xy, input_xy, 0, 1);
auto input_data = rg.generate_random_4d<ov::float16>(batch_num, input_f, input_xy, input_xy, 0, 1);
auto input_data_bfyx = flatten_4d(format::bfyx, input_data);
auto input_mem = engine.allocate_memory({ data_types::f16, format::bfyx, input_size });
set_values(input_mem, input_data_bfyx);
auto weights_size = tensor(output_f, input_f, filter_xy, filter_xy);
auto weights_data = rg.generate_random_4d<FLOAT16>(output_f, input_f, filter_xy, filter_xy, 0, 1);
auto weights_data = rg.generate_random_4d<ov::float16>(output_f, input_f, filter_xy, filter_xy, 0, 1);
auto weights_data_bfyx = flatten_4d(format::bfyx, weights_data);
@ -6485,7 +6485,7 @@ TEST_P(convolution_gpu_block_layout, bfyx_bsv16_fsv16_fp16)
set_values(weights_mem, weights_data_bfyx);
// Will be used to store reference values calculated in branches depending on bias
auto reference_result = VVVVF<FLOAT16>(batch_num, VVVF<FLOAT16>(output_f));
auto reference_result = VVVVF<ov::float16>(batch_num, VVVF<ov::float16>(output_f));
topology topology(
input_layout("input", input_mem->get_layout()),
@ -6498,7 +6498,7 @@ TEST_P(convolution_gpu_block_layout, bfyx_bsv16_fsv16_fp16)
{
// Generate bias data
auto biases_size = tensor(1, output_f, 1, 1);
auto biases_data = rg.generate_random_1d<FLOAT16>(output_f, -1, 1);
auto biases_data = rg.generate_random_1d<ov::float16>(output_f, -1, 1);
auto biases_mem = engine.allocate_memory({ data_types::f16, format::bfyx, biases_size });
set_values(biases_mem, biases_data);
@ -6562,10 +6562,10 @@ TEST_P(convolution_gpu_block_layout, bfyx_bsv16_fsv16_fp16)
network.execute();
auto out_mem = network.get_output("conv_bsv16_fsv16").get_memory();
cldnn::mem_lock<FLOAT16> out_ptr(out_mem, get_test_stream());
cldnn::mem_lock<ov::float16> out_ptr(out_mem, get_test_stream());
auto out_mem_bfyx = network.get_output("reorder_bfyx").get_memory();
cldnn::mem_lock<FLOAT16> out_ptr_bfyx(out_mem_bfyx, get_test_stream());
cldnn::mem_lock<ov::float16> out_ptr_bfyx(out_mem_bfyx, get_test_stream());
ASSERT_EQ(out_mem->get_layout().format, format::bs_fs_yx_bsv16_fsv16);
@ -6784,19 +6784,19 @@ TEST_P(convolution_depthwise_gpu, depthwise_conv_fs_b_yx_fsv32)
const int output_x = 1 + (input_xy + 2 * pad_x - filter_x) / stride + 2 * output_padding;
auto input_size = tensor(batch_num, input_f, input_xy, input_xy);
auto input_data = rg.generate_random_4d<FLOAT16>(batch_num, input_f, input_xy, input_xy, -1, 1);
auto input_data = rg.generate_random_4d<ov::float16>(batch_num, input_f, input_xy, input_xy, -1, 1);
auto input_data_bfyx = flatten_4d(format::bfyx, input_data);
auto input_mem = engine.allocate_memory({ data_types::f16, format::bfyx, input_size });
set_values(input_mem, input_data_bfyx);
auto weights_size = tensor(group(groups), batch(1), feature(1), spatial(filter_x, filter_y));
auto weights_data = rg.generate_random_4d<FLOAT16>(output_f, 1, filter_y, filter_x, -1, 1);
auto weights_data = rg.generate_random_4d<ov::float16>(output_f, 1, filter_y, filter_x, -1, 1);
auto weights_data_bfyx = flatten_4d(format::bfyx, weights_data);
auto weights_mem = engine.allocate_memory({ data_types::f16, format::goiyx, weights_size });
set_values(weights_mem, weights_data_bfyx);
// Will be used to store reference values calculated in branches depending on bias
auto reference_result = VVVVF<FLOAT16>(batch_num, VVVF<FLOAT16>(output_f));
auto reference_result = VVVVF<ov::float16>(batch_num, VVVF<ov::float16>(output_f));
topology topology(
input_layout("input", input_mem->get_layout()),
@ -6839,7 +6839,7 @@ TEST_P(convolution_depthwise_gpu, depthwise_conv_fs_b_yx_fsv32)
network.execute();
auto out_mem = network.get_output("conv_fsv").get_memory();
cldnn::mem_lock<FLOAT16> out_ptr(out_mem, get_test_stream());
cldnn::mem_lock<ov::float16> out_ptr(out_mem, get_test_stream());
ASSERT_EQ(out_mem->get_layout().format, format::fs_b_yx_fsv32);
@ -6928,19 +6928,19 @@ TEST_P(convolution_depthwise_gpu_fsv16, depthwise_conv_b_fs_yx_fsv16)
const int output_x = 1 + (input_xy + 2 * pad_x - filter_x) / stride + 2 * output_padding;
auto input_size = tensor(batch_num, input_f, input_xy, input_xy);
auto input_data = rg.generate_random_4d<FLOAT16>(batch_num, input_f, input_xy, input_xy, -1, 1);
auto input_data = rg.generate_random_4d<ov::float16>(batch_num, input_f, input_xy, input_xy, -1, 1);
auto input_data_bfyx = flatten_4d(format::bfyx, input_data);
auto input_mem = engine.allocate_memory({ data_types::f16, format::bfyx, input_size });
set_values(input_mem, input_data_bfyx);
auto weights_size = tensor(group(output_f), batch(1), feature(1), spatial(filter_x, filter_y));
auto weights_data = rg.generate_random_4d<FLOAT16>(output_f, 1, filter_y, filter_x, -1, 1);
auto weights_data = rg.generate_random_4d<ov::float16>(output_f, 1, filter_y, filter_x, -1, 1);
auto weights_data_bfyx = flatten_4d(format::bfyx, weights_data);
auto weights_mem = engine.allocate_memory({ data_types::f16, format::goiyx, weights_size });
set_values(weights_mem, weights_data_bfyx);
// Will be used to store reference values calculated in branches depending on bias
auto reference_result = VVVVF<FLOAT16>(batch_num, VVVF<FLOAT16>(output_f));
auto reference_result = VVVVF<ov::float16>(batch_num, VVVF<ov::float16>(output_f));
topology topology(
input_layout("input", input_mem->get_layout()),
@ -6983,7 +6983,7 @@ TEST_P(convolution_depthwise_gpu_fsv16, depthwise_conv_b_fs_yx_fsv16)
network.execute();
auto out_mem = network.get_output("conv_fsv").get_memory();
cldnn::mem_lock<FLOAT16> out_ptr(out_mem, get_test_stream());
cldnn::mem_lock<ov::float16> out_ptr(out_mem, get_test_stream());
ASSERT_EQ(out_mem->get_layout().format, format::b_fs_yx_fsv16);
@ -7060,19 +7060,19 @@ TEST_P(convolution_depthwise_gpu_fsv16_xy, depthwise_conv_b_fs_yx_fsv16)
const int output_x = 1 + (input_x + 2 * pad_x - filter_x) / stride + 2 * output_padding;
auto input_size = tensor(batch_num, input_f, input_x, input_y);
auto input_data = rg.generate_random_4d<FLOAT16>(batch_num, input_f, input_y, input_x, -1, 1);
auto input_data = rg.generate_random_4d<ov::float16>(batch_num, input_f, input_y, input_x, -1, 1);
auto input_data_bfyx = flatten_4d(format::bfyx, input_data);
auto input_mem = engine.allocate_memory({ data_types::f16, format::bfyx, input_size });
set_values(input_mem, input_data_bfyx);
auto weights_size = tensor(group(output_f), batch(1), feature(1), spatial(filter_x, filter_y));
auto weights_data = rg.generate_random_4d<FLOAT16>(output_f, 1, filter_y, filter_x, -1, 1);
auto weights_data = rg.generate_random_4d<ov::float16>(output_f, 1, filter_y, filter_x, -1, 1);
auto weights_data_bfyx = flatten_4d(format::bfyx, weights_data);
auto weights_mem = engine.allocate_memory({ data_types::f16, format::goiyx, weights_size });
set_values(weights_mem, weights_data_bfyx);
// Will be used to store reference values calculated in branches depending on bias
auto reference_result = VVVVF<FLOAT16>(batch_num, VVVF<FLOAT16>(output_f));
auto reference_result = VVVVF<ov::float16>(batch_num, VVVF<ov::float16>(output_f));
topology topology(
input_layout("input", input_mem->get_layout()),
@ -7122,7 +7122,7 @@ TEST_P(convolution_depthwise_gpu_fsv16_xy, depthwise_conv_b_fs_yx_fsv16)
auto out_mem = network.get_output("out").get_memory();
cldnn::mem_lock<FLOAT16> out_ptr(out_mem, get_test_stream());
cldnn::mem_lock<ov::float16> out_ptr(out_mem, get_test_stream());
ASSERT_EQ(out_mem->get_layout().format, format::b_fs_yx_fsv16);
for (int bi = 0; bi < batch_num; ++bi) {
@ -7276,19 +7276,19 @@ TEST_P(convolution_depthwise_gpu_bfyx, depthwise_conv_bfyx)
const int output_x = 1 + (input_xy + 2 * pad_x - filter_x) / stride + 2 * output_padding;
auto input_size = tensor(batch_num, input_f, input_xy, input_xy);
auto input_data = rg.generate_random_4d<FLOAT16>(batch_num, input_f, input_xy, input_xy, -1, 1);
auto input_data = rg.generate_random_4d<ov::float16>(batch_num, input_f, input_xy, input_xy, -1, 1);
auto input_data_bfyx = flatten_4d(format::bfyx, input_data);
auto input_mem = engine.allocate_memory({ data_types::f16, format::bfyx, input_size });
set_values(input_mem, input_data_bfyx);
auto weights_size = tensor(group(output_f), batch(1), feature(1), spatial(filter_x, filter_y));
auto weights_data = rg.generate_random_4d<FLOAT16>(output_f, 1, filter_y, filter_x, -1, 1);
auto weights_data = rg.generate_random_4d<ov::float16>(output_f, 1, filter_y, filter_x, -1, 1);
auto weights_data_bfyx = flatten_4d(format::bfyx, weights_data);
auto weights_mem = engine.allocate_memory({ data_types::f16, format::goiyx, weights_size });
set_values(weights_mem, weights_data_bfyx);
// Will be used to store reference values calculated in branches depending on bias
auto reference_result = VVVVF<FLOAT16>(batch_num, VVVF<FLOAT16>(output_f));
auto reference_result = VVVVF<ov::float16>(batch_num, VVVF<ov::float16>(output_f));
topology topology(
input_layout("input", input_mem->get_layout()),
@ -7328,7 +7328,7 @@ TEST_P(convolution_depthwise_gpu_bfyx, depthwise_conv_bfyx)
network.execute();
auto out_mem = network.get_output("conv").get_memory();
cldnn::mem_lock<FLOAT16> out_ptr(out_mem, get_test_stream());
cldnn::mem_lock<ov::float16> out_ptr(out_mem, get_test_stream());
ASSERT_EQ(out_mem->get_layout().format, format::bfyx);
@ -7726,25 +7726,25 @@ TEST_P(convolution_general_gpu, conv_fp16_cases) {
auto with_bias = testing::get<13>(GetParam());
auto input_size = tensor(batch_num, input_f, input_x, input_y);
auto input_data = rg.generate_random_4d<FLOAT16>(batch_num, input_f, input_y, input_x, -1, 1);
auto input_data = rg.generate_random_4d<ov::float16>(batch_num, input_f, input_y, input_x, -1, 1);
auto input_data_bfyx = flatten_4d(format::bfyx, input_data);
auto input_mem = engine.allocate_memory({ data_types::f16, format::bfyx, input_size });
set_values(input_mem, input_data_bfyx);
auto weights_size = tensor(output_f, input_f, filter_y, filter_x, 1);
auto weights_data = rg.generate_random_4d<FLOAT16>(output_f, input_f, filter_y, filter_x, -1, 1);
auto weights_data = rg.generate_random_4d<ov::float16>(output_f, input_f, filter_y, filter_x, -1, 1);
auto weights_data_bfyx = flatten_4d(format::bfyx, weights_data);
auto weights_mem = engine.allocate_memory({ data_types::f16, format::bfyx, weights_size });
set_values(weights_mem, weights_data_bfyx);
// Will be used to store reference values calculated in branches depending on bias
auto expected_result = VVVVF<FLOAT16>(batch_num, VVVF<FLOAT16>(output_f));
auto expected_result = VVVVF<ov::float16>(batch_num, VVVF<ov::float16>(output_f));
topology topology;
// Calculate reference values
if (with_bias) {
auto biases_size = tensor(1, output_f, 1, 1);
auto biases_data = rg.generate_random_1d<FLOAT16>(output_f, -1, 1);
auto biases_data = rg.generate_random_1d<ov::float16>(output_f, -1, 1);
auto biases_mem = engine.allocate_memory({ data_types::f16, format::bfyx, biases_size });
set_values(biases_mem, biases_data);
@ -7818,7 +7818,7 @@ TEST_P(convolution_general_gpu, conv_fp16_cases) {
network.execute();
auto out_mem = network.get_output("conv_fsv").get_memory();
cldnn::mem_lock<FLOAT16> out_ptr(out_mem, get_test_stream());
cldnn::mem_lock<ov::float16> out_ptr(out_mem, get_test_stream());
auto out_lay = out_mem->get_layout();
ASSERT_EQ(out_mem->get_layout().format, input_data_format);
@ -7886,13 +7886,13 @@ TEST_P(convolution_gpu_fsv16_to_bfyx, conv_b_fs_yx_fsv16_to_bfyx_padding)
const std::ptrdiff_t pad_x = (filter_x - 1) / 2;
auto input_size = tensor(input_b, input_f, input_x, input_y);
auto input_data = rg.generate_random_4d<FLOAT16>(input_b, input_f, input_y, input_x, -1, 1);
auto input_data = rg.generate_random_4d<ov::float16>(input_b, input_f, input_y, input_x, -1, 1);
auto input_data_bfyx = flatten_4d(format::bfyx, input_data);
auto input_mem = engine.allocate_memory({ data_types::f16, format::bfyx, input_size });
set_values(input_mem, input_data_bfyx);
auto weights_size = tensor(input_b, input_f, filter_x, filter_y, 1);
auto weights_data = rg.generate_random_4d<FLOAT16>(input_b, input_f, filter_x, filter_y, -1, 1);
auto weights_data = rg.generate_random_4d<ov::float16>(input_b, input_f, filter_x, filter_y, -1, 1);
auto weights_data_bfyx = flatten_4d(format::bfyx, weights_data);
auto weights_mem = engine.allocate_memory({ data_types::f16, format::oiyx, weights_size });
set_values(weights_mem, weights_data_bfyx);
@ -7926,7 +7926,7 @@ TEST_P(convolution_gpu_fsv16_to_bfyx, conv_b_fs_yx_fsv16_to_bfyx_padding)
auto ref_out = network_ref.execute();
auto ref_out_mem = ref_out.begin()->second.get_memory();
cldnn::mem_lock<FLOAT16> ref_out_ptr(ref_out_mem, get_test_stream());
cldnn::mem_lock<ov::float16> ref_out_ptr(ref_out_mem, get_test_stream());
// Exec target network (fusing: conv+reorder)
ExecutionConfig config_target = get_test_default_config(engine);
@ -7939,7 +7939,7 @@ TEST_P(convolution_gpu_fsv16_to_bfyx, conv_b_fs_yx_fsv16_to_bfyx_padding)
auto target_out = network_target.execute();
auto target_out_mem = target_out.begin()->second.get_memory();
cldnn::mem_lock<FLOAT16> target_out_ptr(target_out_mem, get_test_stream());
cldnn::mem_lock<ov::float16> target_out_ptr(target_out_mem, get_test_stream());
// Compare ref and target result
for (size_t i = 0; i < ref_out_ptr.size(); i++) {
@ -7986,13 +7986,13 @@ TEST_P(convolution_gpu_fsv16_to_bfyx, conv_b_fs_yx_fsv16_to_bfyx_different_type)
const std::ptrdiff_t pad_x = (filter_x - 1) / 2;
auto input_size = tensor(input_b, input_f, input_x, input_y);
auto input_data = rg.generate_random_4d<FLOAT16>(input_b, input_f, input_y, input_x, -1, 1);
auto input_data = rg.generate_random_4d<ov::float16>(input_b, input_f, input_y, input_x, -1, 1);
auto input_data_bfyx = flatten_4d(format::bfyx, input_data);
auto input_mem = engine.allocate_memory({ data_types::f16, format::bfyx, input_size });
set_values(input_mem, input_data_bfyx);
auto weights_size = tensor(input_b, input_f, filter_x, filter_y, 1);
auto weights_data = rg.generate_random_4d<FLOAT16>(input_b, input_f, filter_x, filter_y, -1, 1);
auto weights_data = rg.generate_random_4d<ov::float16>(input_b, input_f, filter_x, filter_y, -1, 1);
auto weights_data_bfyx = flatten_4d(format::bfyx, weights_data);
auto weights_mem = engine.allocate_memory({ data_types::f16, format::goiyx, weights_size });
set_values(weights_mem, weights_data_bfyx);
@ -8275,7 +8275,7 @@ protected:
bool bigger_pad() { return _bigger_pad; }
bool grouped_weights_shape() { return _grouped_weights_shape; }
data_types input_type() const { return type_to_data_type<InputT>::value; }
data_types input_type() const { return ov::element::from<InputT>(); }
format input_format() const { return _input_fmt; }
tensor input_size() const {
return tensor(TensorValue(batch_num()),
@ -8284,7 +8284,7 @@ protected:
TensorValue(input_y()));
}
data_types weights_type() const { return type_to_data_type<WeightsT>::value; }
data_types weights_type() const { return ov::element::from<WeightsT>(); }
tensor weights_size() const {
return tensor(TensorValue(output_features()),
TensorValue(weights_input_features()),
@ -8314,7 +8314,7 @@ protected:
}
}
data_types output_type() const { return type_to_data_type<OutputT>::value; }
data_types output_type() const { return ov::element::from<OutputT>(); }
};
struct convolution_random_test_all_params {
@ -8995,7 +8995,7 @@ public:
if (generic_params->data_type == data_types::f32) {
prepare_input_for_test_typed<float>(inputs);
} else {
prepare_input_for_test_typed<FLOAT16>(inputs);
prepare_input_for_test_typed<ov::float16>(inputs);
}
}
@ -9128,7 +9128,7 @@ public:
if (generic_params->data_type == data_types::f32) {
return generate_reference_typed<float>(inputs);
} else {
return generate_reference_typed<FLOAT16>(inputs);
return generate_reference_typed<ov::float16>(inputs);
}
}
@ -9236,25 +9236,25 @@ TEST_P(convolution_gpu_onednn, conv_onednn_cases) {
auto with_bias = testing::get<13>(GetParam());
auto input_size = tensor(batch_num, input_f, input_x, input_y);
auto input_data = rg.generate_random_4d<FLOAT16>(batch_num, input_f, input_y, input_x, -1, 1);
auto input_data = rg.generate_random_4d<ov::float16>(batch_num, input_f, input_y, input_x, -1, 1);
auto input_data_bfyx = flatten_4d(format::bfyx, input_data);
auto input_mem = engine.allocate_memory({ data_types::f16, format::bfyx, input_size });
set_values(input_mem, input_data_bfyx);
auto weights_size = tensor(output_f, input_f, filter_y, filter_x, 1);
auto weights_data = rg.generate_random_4d<FLOAT16>(output_f, input_f, filter_y, filter_x, -1, 1);
auto weights_data = rg.generate_random_4d<ov::float16>(output_f, input_f, filter_y, filter_x, -1, 1);
auto weights_data_bfyx = flatten_4d(format::bfyx, weights_data);
auto weights_mem = engine.allocate_memory({ data_types::f16, format::bfyx, weights_size });
set_values(weights_mem, weights_data_bfyx);
// Will be used to store reference values calculated in branches depending on bias
auto expected_result = VVVVF<FLOAT16>(batch_num, VVVF<FLOAT16>(output_f));
auto expected_result = VVVVF<ov::float16>(batch_num, VVVF<ov::float16>(output_f));
topology topology;
// Calculate reference values
if (with_bias) {
auto biases_size = tensor(1, output_f, 1, 1);
auto biases_data = rg.generate_random_1d<FLOAT16>(output_f, -1, 1);
auto biases_data = rg.generate_random_1d<ov::float16>(output_f, -1, 1);
auto biases_mem = engine.allocate_memory({ data_types::f16, format::bfyx, biases_size });
set_values(biases_mem, biases_data);
@ -9332,7 +9332,7 @@ TEST_P(convolution_gpu_onednn, conv_onednn_cases) {
for (auto& p : network.get_primitives_info())
std::cerr << p.original_id << " " << p.kernel_id << std::endl;
auto out_ptr = get_output_values_to_float<FLOAT16>(network, outputs.find("conv_fsv")->second);
auto out_ptr = get_output_values_to_float<ov::float16>(network, outputs.find("conv_fsv")->second);
auto out_lay = network.get_node_output_layout("conv_fsv");
ASSERT_EQ(out_lay.batch(), expected_result.size());
ASSERT_EQ(out_lay.feature(), expected_result[0].size());
@ -9368,13 +9368,13 @@ TEST(convolution_gpu_onednn, padding_for_cldnn_kernel_after_onednn) {
int output_b = 1, output_f = 16, output_y = 6, output_x = 6;
auto input_size = tensor(input_b, input_f, input_x, input_y);
auto input_data = rg.generate_random_4d<FLOAT16>(input_b, input_f, input_y, input_x, -1, 1);
auto input_data = rg.generate_random_4d<ov::float16>(input_b, input_f, input_y, input_x, -1, 1);
auto input_data_bfyx = flatten_4d(format::bfyx, input_data);
auto input_mem = engine.allocate_memory({ data_types::f16, format::bfyx, input_size });
set_values(input_mem, input_data_bfyx);
auto weights_size = tensor(16, 16, 1, 1, 1);
auto weights_data = rg.generate_random_4d<FLOAT16>(output_f, input_f, 1, 1, -1, 1);
auto weights_data = rg.generate_random_4d<ov::float16>(output_f, input_f, 1, 1, -1, 1);
auto weights_data_bfyx = flatten_4d(format::bfyx, weights_data);
auto weights_mem = engine.allocate_memory({ data_types::f16, format::bfyx, weights_size });
set_values(weights_mem, weights_data_bfyx);
@ -9448,11 +9448,11 @@ TEST(convolution_gpu_onednn, spatial_1d) {
ov::PartialShape weights_pshape = {16, 16, 3};
layout in_layout{ input_pshape, data_types::f16, format::bfyx };
layout weights_layout{ weights_pshape, data_types::f16, format::bfyx };
auto input_data = rg.generate_random_1d<FLOAT16>(in_layout.count(), -1, 1);
auto input_data = rg.generate_random_1d<ov::float16>(in_layout.count(), -1, 1);
auto input_mem = engine.allocate_memory(in_layout);
set_values(input_mem, input_data);
auto weights_data = rg.generate_random_1d<FLOAT16>(weights_layout.count(), -1, 1);
auto weights_data = rg.generate_random_1d<ov::float16>(weights_layout.count(), -1, 1);
auto weights_mem = engine.allocate_memory(weights_layout);
set_values(weights_mem, weights_data);
@ -9865,11 +9865,11 @@ void test_convolution_f32_gpu_convolution_gpu_bfyx_f16_depthwise_x_block_size_1(
}
TEST(convolution_f32_gpu, convolution_gpu_bfyx_f16_depthwise_x_block_size_1) {
test_convolution_f32_gpu_convolution_gpu_bfyx_f16_depthwise_x_block_size_1<FLOAT16>(false);
test_convolution_f32_gpu_convolution_gpu_bfyx_f16_depthwise_x_block_size_1<ov::float16>(false);
}
TEST(export_import_convolution_f32_gpu, convolution_gpu_bfyx_f16_depthwise_x_block_size_1) {
test_convolution_f32_gpu_convolution_gpu_bfyx_f16_depthwise_x_block_size_1<FLOAT16>(true);
test_convolution_f32_gpu_convolution_gpu_bfyx_f16_depthwise_x_block_size_1<ov::float16>(true);
}

13
src/plugins/intel_gpu/tests/unit/test_cases/ctc_loss_gpu_test.cpp
View File

@ -51,8 +51,8 @@ public:
std::tie(p, fmt, is_caching_test) = testing::TestWithParam<ctc_loss_test_params<TF, TI>>::GetParam();
auto& engine = get_test_engine();
const auto float_data_type = type_to_data_type<TF>::value;
const auto int_data_type = type_to_data_type<TI>::value;
const auto float_data_type = ov::element::from<TF>();
const auto int_data_type = ov::element::from<TI>();
const auto plane_format = format::bfyx;
std::vector<std::tuple<primitive_id, memory::ptr, data_types>> inputs;
@ -241,13 +241,14 @@ const std::vector<format::type> layout_formats = {
testing::Values(false)), \
ctc_loss_gpu_test_##float_type##int_type::PrintToStringParamName);
using ov::float16;
INSTANTIATE_CTC_LOSS_TEST_SUITE(float, int64_t);
INSTANTIATE_CTC_LOSS_TEST_SUITE(FLOAT16, int32_t);
INSTANTIATE_CTC_LOSS_TEST_SUITE(float16, int32_t);
INSTANTIATE_TEST_SUITE_P(export_import,
ctc_loss_gpu_test_FLOAT16int32_t,
testing::Combine(testing::Values(getCTCLossParams<FLOAT16, int32_t>()[0]),
ctc_loss_gpu_test_float16int32_t,
testing::Combine(testing::Values(getCTCLossParams<ov::float16, int32_t>()[0]),
testing::Values(layout_formats[0]),
testing::Values(true)),
ctc_loss_gpu_test_FLOAT16int32_t::PrintToStringParamName);
ctc_loss_gpu_test_float16int32_t::PrintToStringParamName);
} // namespace

8
src/plugins/intel_gpu/tests/unit/test_cases/cum_sum_gpu_test.cpp
View File

@ -152,7 +152,7 @@ public:
data_types get_alloc_data_type(void) {
if (std::is_same<input_type, float>::value)
return data_types::f32;
else if (std::is_same<input_type, FLOAT16>::value)
else if (std::is_same<input_type, ov::float16>::value)
return data_types::f16;
else if (std::is_same<input_type, int32_t>::value)
return data_types::i32;
@ -181,7 +181,7 @@ public:
auto input = engine.allocate_memory({ get_alloc_data_type(), in_out_format, shape });
const int inputSize = b * f * w * z * y * x;
VF<input_type> inputVals = std::is_same<input_type, FLOAT16>::value ?
VF<input_type> inputVals = std::is_same<input_type, ov::float16>::value ?
rg.generate_random_1d<input_type>(inputSize, -1, 1, 1) :
rg.generate_random_1d<input_type>(inputSize, -100, 100, 8);
@ -211,7 +211,7 @@ public:
}
};
class cum_sum_gpu_fp16 : public ::cum_sum_gpu<cum_sum_test_params, FLOAT16, FLOAT16> {};
class cum_sum_gpu_fp16 : public ::cum_sum_gpu<cum_sum_test_params, ov::float16, ov::float16> {};
class cum_sum_gpu_fp32 : public ::cum_sum_gpu<cum_sum_test_params, float, float> {};
class cum_sum_gpu_int32 : public ::cum_sum_gpu<cum_sum_test_params, int32_t, int32_t> {};
class cum_sum_gpu_int64 : public ::cum_sum_gpu<cum_sum_test_params, int64_t, int64_t> {};
@ -282,7 +282,7 @@ TEST(cum_sum_gpu_f16, DISABLED_basic_1d) {
};
auto input = engine.allocate_memory({ data_types::f16, format::bfyx, shape });
set_values(input, vectorCast<FLOAT16>(inputVals));
set_values(input, vectorCast<ov::float16>(inputVals));
topology topology;
topology.add(input_layout("Input0", input->get_layout()));

66
src/plugins/intel_gpu/tests/unit/test_cases/deconvolution_gpu_test.cpp
View File

@ -31,7 +31,7 @@ struct deconvolution_traits<int8_t> {
};
template <>
struct deconvolution_traits<FLOAT16> {
struct deconvolution_traits<ov::float16> {
using accumulator_type = float;
};
@ -984,11 +984,11 @@ TYPED_TEST(deconvolution_basic, basic_f16_wsiz2x2_in2x2x1x2_bfyx_yxfb_stride2_pa
ov::intel_gpu::ExecutionConfig config = get_test_default_config(engine);
config.set_property(ov::intel_gpu::optimize_data(true));
set_values(input, { FLOAT16(8.f), FLOAT16(0.5f),
FLOAT16(6.f), FLOAT16(9.f),
set_values(input, { ov::float16(8.f), ov::float16(0.5f),
ov::float16(6.f), ov::float16(9.f),
FLOAT16(1.f), FLOAT16(3.f),
FLOAT16(2.f), FLOAT16(4.f) });
ov::float16(1.f), ov::float16(3.f),
ov::float16(2.f), ov::float16(4.f) });
set_values(weights, { -2.f, 2.f,
7.f, -0.5f});
set_values(biases, { 1.0f });
@ -1758,11 +1758,11 @@ TYPED_TEST(deconvolution_basic, basic_f16_k9x9_s2x2_pad4x4) {
tests::random_generator rg(GET_SUITE_NAME);
auto& engine = get_test_engine();
VVVVF<FLOAT16> input_rnd = rg.generate_random_4d<FLOAT16>(1, 32, 16, 16, -2, 2);
VF<FLOAT16> input_rnd_vec = flatten_4d<FLOAT16>(format::bfyx, input_rnd);
VVVVF<FLOAT16> filter_rnd = rg.generate_random_4d<FLOAT16>(1, 32, 9, 9, -1, 1);
VF<FLOAT16> filter_rnd_vec = flatten_4d<FLOAT16>(format::bfyx, filter_rnd);
VF<FLOAT16> bias_rnd = rg.generate_random_1d<FLOAT16>(1, -1, 1);
VVVVF<ov::float16> input_rnd = rg.generate_random_4d<ov::float16>(1, 32, 16, 16, -2, 2);
VF<ov::float16> input_rnd_vec = flatten_4d<ov::float16>(format::bfyx, input_rnd);
VVVVF<ov::float16> filter_rnd = rg.generate_random_4d<ov::float16>(1, 32, 9, 9, -1, 1);
VF<ov::float16> filter_rnd_vec = flatten_4d<ov::float16>(format::bfyx, filter_rnd);
VF<ov::float16> bias_rnd = rg.generate_random_1d<ov::float16>(1, -1, 1);
VF<float> filter_rnd_f32_vec, bias_f32_rnd;
for (unsigned int i = 0; i < filter_rnd_vec.size(); i++)
@ -1797,9 +1797,9 @@ TYPED_TEST(deconvolution_basic, basic_f16_k9x9_s2x2_pad4x4) {
auto outputs_ref = network_ref.execute();
auto output_ref_prim = outputs_ref.at("plane_output").get_memory();
cldnn::mem_lock<FLOAT16> output_ref_ptr(output_ref_prim, get_test_stream());
cldnn::mem_lock<ov::float16> output_ref_ptr(output_ref_prim, get_test_stream());
std::vector<FLOAT16> output_vec_ref;
std::vector<ov::float16> output_vec_ref;
for (unsigned int i = 0; i < output_ref_prim->get_layout().count(); i++) {
output_vec_ref.push_back(output_ref_ptr[i]);
}
@ -1821,7 +1821,7 @@ TYPED_TEST(deconvolution_basic, basic_f16_k9x9_s2x2_pad4x4) {
ASSERT_EQ(outputs_act.size(), size_t(1));
ASSERT_EQ(outputs_act.begin()->first, "out");
auto output_act_prim = outputs_act.begin()->second.get_memory();
cldnn::mem_lock<FLOAT16> output_act_ptr(output_act_prim, get_test_stream());
cldnn::mem_lock<ov::float16> output_act_ptr(output_act_prim, get_test_stream());
std::vector<float> output_vec;
for (unsigned int i = 0; i < output_act_prim->get_layout().count(); i++) {
@ -1924,14 +1924,14 @@ TEST(deconvolution_f16_fw_gpu, basic_wsiz2x2_in2x2x1x2_b_fs_yx_fsv16_stride2_pad
auto weights = engine.allocate_memory({ data_types::f16, format::oiyx,{ 1, 1, 2, 2 } });
auto biases = engine.allocate_memory({ data_types::f16, format::bfyx,{ 1, 1, 1, 1 } });
set_values(input, { FLOAT16(8.f), FLOAT16(0.5f),
FLOAT16(6.f), FLOAT16(9.f),
set_values(input, { ov::float16(8.f), ov::float16(0.5f),
ov::float16(6.f), ov::float16(9.f),
FLOAT16(1.f), FLOAT16(3.f),
FLOAT16(2.f), FLOAT16(4.f) });
set_values(weights, { FLOAT16(-2.f), FLOAT16(2.f),
FLOAT16(7.f), FLOAT16(-0.5f)});
set_values(biases, { FLOAT16(1.0f) });
ov::float16(1.f), ov::float16(3.f),
ov::float16(2.f), ov::float16(4.f) });
set_values(weights, { ov::float16(-2.f), ov::float16(2.f),
ov::float16(7.f), ov::float16(-0.5f)});
set_values(biases, { ov::float16(1.0f) });
topology topology(
input_layout("input", input->get_layout()),
@ -2412,14 +2412,14 @@ void test_deconvolution_f16_fw_gpu_basic_wsiz2x2_in1x2x2x2_fs_b_yx_fsv32_stride1
auto weights = engine.allocate_memory({ data_types::f16, format::bfyx,{ 2, 1, 2, 2 } });
auto biases = engine.allocate_memory({ data_types::f16, format::bfyx,{ 1, 2, 1, 1 } });
set_values(input, { FLOAT16(8.f), FLOAT16(0.5f), FLOAT16(6.f), FLOAT16(9.f),
FLOAT16(1.f), FLOAT16(3.f), FLOAT16(2.f), FLOAT16(4.f)
set_values(input, { ov::float16(8.f), ov::float16(0.5f), ov::float16(6.f), ov::float16(9.f),
ov::float16(1.f), ov::float16(3.f), ov::float16(2.f), ov::float16(4.f)
});
set_values(weights, {
FLOAT16(-2.f), FLOAT16(2.f), FLOAT16(7.f), FLOAT16(-0.5f),
FLOAT16(-4.f), FLOAT16(1.f), FLOAT16(-9.f), FLOAT16(-7.f)
ov::float16(-2.f), ov::float16(2.f), ov::float16(7.f), ov::float16(-0.5f),
ov::float16(-4.f), ov::float16(1.f), ov::float16(-9.f), ov::float16(-7.f)
});
set_values(biases, { FLOAT16(1.0f), FLOAT16(-1.0f) });
set_values(biases, { ov::float16(1.0f), ov::float16(-1.0f) });
topology topology(
input_layout("input", input->get_layout()),
@ -2544,8 +2544,8 @@ struct typed_comparator<float> {
};
template <>
struct typed_comparator<FLOAT16> {
static ::testing::AssertionResult compare(const char* lhs_expr, const char* rhs_expr, FLOAT16 ref, FLOAT16 val) {
struct typed_comparator<ov::float16> {
static ::testing::AssertionResult compare(const char* lhs_expr, const char* rhs_expr, ov::float16 ref, ov::float16 val) {
double abs_error = std::abs(0.05 * (double)ref);
return ::testing::internal::DoubleNearPredFormat(lhs_expr, rhs_expr, "5 percent", (double)ref, (double)val, abs_error);
}
@ -2652,8 +2652,8 @@ public:
type_test_ranges<WeightsT>::min,
type_test_ranges<WeightsT>::max);
auto in_layout = cldnn::layout(cldnn::type_to_data_type<InputT>::value, params.input_format, params.input_size);
auto wei_layout = cldnn::layout(cldnn::type_to_data_type<WeightsT>::value, params.weights_format, params.weights_size);
auto in_layout = cldnn::layout(ov::element::from<InputT>(), params.input_format, params.input_size);
auto wei_layout = cldnn::layout(ov::element::from<WeightsT>(), params.weights_format, params.weights_size);
auto wei_mem = eng.allocate_memory(wei_layout);
auto in_mem = eng.allocate_memory(in_layout);
@ -2670,7 +2670,7 @@ public:
if (params.with_bias) {
auto bias_size = cldnn::tensor(feature(params.weights_size.batch[0] * params.weights_size.group[0]));
auto bias_lay = cldnn::layout(cldnn::type_to_data_type<OutputT>::value, cldnn::format::bfyx, bias_size);
auto bias_lay = cldnn::layout(ov::element::from<OutputT>(), cldnn::format::bfyx, bias_size);
auto bias_mem = eng.allocate_memory(bias_lay);
bias_data = rg.generate_random_1d<OutputT>(bias_lay.feature(), -1, 1);
set_values(bias_mem, bias_data);
@ -2763,7 +2763,7 @@ protected:
run_typed_in<float>();
break;
case data_types::f16:
run_typed_in<FLOAT16>();
run_typed_in<ov::float16>();
break;
case data_types::i8:
run_typed_in<int8_t>();
@ -2795,7 +2795,7 @@ private:
run_typed<InputT, WeightsT, float>();
break;
case data_types::f16:
run_typed<InputT, WeightsT, FLOAT16>();
run_typed<InputT, WeightsT, ov::float16>();
break;
default:
break;
@ -2810,7 +2810,7 @@ private:
run_typed_in_wei<InputT, float>();
break;
case data_types::f16:
run_typed_in_wei<InputT, FLOAT16>();
run_typed_in_wei<InputT, ov::float16>();
break;
case data_types::i8:
run_typed_in_wei<InputT, int8_t>();

18
src/plugins/intel_gpu/tests/unit/test_cases/depth_concatenate_gpu_test.cpp
View File

@ -417,17 +417,17 @@ TEST(depth_concatenate_f32_gpu, test06_padded_input) {
auto input1 = engine.allocate_memory({ data_types::f16, format::fs_b_yx_fsv32, {1, input_f, 1, 1} });
auto input2 = engine.allocate_memory({ data_types::f16, format::fs_b_yx_fsv32, {1, input_f, 1, 1} });
auto input1_data = rg.generate_random_4d<FLOAT16>(1, input_f, 1, 1, -1, 1);
auto input2_data = rg.generate_random_4d<FLOAT16>(1, input_f, 1, 1, -1, 1);
auto input1_data = rg.generate_random_4d<ov::float16>(1, input_f, 1, 1, -1, 1);
auto input2_data = rg.generate_random_4d<ov::float16>(1, input_f, 1, 1, -1, 1);
set_values(input1, flatten_4d(format::bfyx, input1_data));
set_values(input2, flatten_4d(format::bfyx, input2_data));
auto weights = engine.allocate_memory({ data_types::f16, format::oiyx, {input_f, input_f, 3, 3} });
// Construct weights for convolution that just double input values.
VVVVF<FLOAT16> weights_data;
VVVVF<ov::float16> weights_data;
weights_data.resize(input_f);
for (size_t oi = 0; oi < input_f; ++oi) {
weights_data[oi].resize(input_f, VVF<FLOAT16>(3, VF<FLOAT16>(3, FLOAT16(0.f))));
weights_data[oi].resize(input_f, VVF<ov::float16>(3, VF<ov::float16>(3, ov::float16(0.f))));
weights_data[oi][oi][1][1] = 2.f;
}
set_values(weights, flatten_4d(format::bfyx, weights_data));
@ -500,17 +500,17 @@ TEST(depth_concatenate_f32_gpu, test07_padded_output) {
auto input1 = engine.allocate_memory({ data_types::f16, format::fs_b_yx_fsv32, {1, input_f, 1, 1} });
auto input2 = engine.allocate_memory({ data_types::f16, format::fs_b_yx_fsv32, {1, input_f, 1, 1} });
auto input1_data = rg.generate_random_4d<FLOAT16>(1, input_f, 1, 1, -1, 1);
auto input2_data = rg.generate_random_4d<FLOAT16>(1, input_f, 1, 1, -1, 1);
auto input1_data = rg.generate_random_4d<ov::float16>(1, input_f, 1, 1, -1, 1);
auto input2_data = rg.generate_random_4d<ov::float16>(1, input_f, 1, 1, -1, 1);
set_values(input1, flatten_4d(format::bfyx, input1_data));
set_values(input2, flatten_4d(format::bfyx, input2_data));
auto weights = engine.allocate_memory({ data_types::f16, format::oiyx, {output_f, output_f, 3, 3} });
// Construct weights for convolution that just double input values.
VVVVF<FLOAT16> weights_data;
VVVVF<ov::float16> weights_data;
weights_data.resize(output_f);
for (size_t oi = 0; oi < output_f; ++oi) {
weights_data[oi].resize(output_f, VVF<FLOAT16>(3, VF<FLOAT16>(3, FLOAT16(0.f))));
weights_data[oi].resize(output_f, VVF<ov::float16>(3, VF<ov::float16>(3, ov::float16(0.f))));
weights_data[oi][oi][1][1] = 2.f;
}
set_values(weights, flatten_4d(format::bfyx, weights_data));
@ -1248,7 +1248,7 @@ public:
if (generic_params->data_type == data_types::f32) {
return generate_reference_typed<float>(inputs);
} else {
return generate_reference_typed<FLOAT16>(inputs);
return generate_reference_typed<ov::float16>(inputs);
}
}

54
src/plugins/intel_gpu/tests/unit/test_cases/depth_to_space_gpu_test.cpp
View File

@ -28,8 +28,8 @@ TEST(depth_to_space_fp16_gpu, d1411_bs2) {
size_t block_size = 2;
set_values(input1, {
FLOAT16(0.0f), FLOAT16(1.0f),
FLOAT16(2.0f), FLOAT16(3.0f)
ov::float16(0.0f), ov::float16(1.0f),
ov::float16(2.0f), ov::float16(3.0f)
});
topology topology;
@ -68,10 +68,10 @@ TEST(depth_to_space_fp16_gpu, d1421_bs2) {
size_t block_size = 2;
set_values(input1, {
FLOAT16(0.0f), FLOAT16(1.0f),
FLOAT16(2.0f), FLOAT16(3.0f),
FLOAT16(4.0f), FLOAT16(5.0f),
FLOAT16(6.0f), FLOAT16(7.0f)
ov::float16(0.0f), ov::float16(1.0f),
ov::float16(2.0f), ov::float16(3.0f),
ov::float16(4.0f), ov::float16(5.0f),
ov::float16(6.0f), ov::float16(7.0f)
});
topology topology;
@ -110,23 +110,23 @@ TEST(depth_to_space_fp16_gpu, d1933_bs3) {
size_t block_size = 3;
set_values(input1, {
FLOAT16(0.0f), FLOAT16(1.0f), FLOAT16(2.0f), FLOAT16(3.0f), FLOAT16(4.0f),
FLOAT16(5.0f), FLOAT16(6.0f), FLOAT16(7.0f), FLOAT16(8.0f), FLOAT16(9.0f),
FLOAT16(10.0f), FLOAT16(11.0f), FLOAT16(12.0f), FLOAT16(13.0f), FLOAT16(14.0f),
FLOAT16(15.0f), FLOAT16(16.0f), FLOAT16(17.0f), FLOAT16(18.0f), FLOAT16(19.0f),
FLOAT16(20.0f), FLOAT16(21.0f), FLOAT16(22.0f), FLOAT16(23.0f), FLOAT16(24.0f),
FLOAT16(25.0f), FLOAT16(26.0f), FLOAT16(27.0f), FLOAT16(28.0f), FLOAT16(29.0f),
FLOAT16(30.0f), FLOAT16(31.0f), FLOAT16(32.0f), FLOAT16(33.0f), FLOAT16(34.0f),
FLOAT16(35.0f), FLOAT16(36.0f), FLOAT16(37.0f), FLOAT16(38.0f), FLOAT16(39.0f),
FLOAT16(40.0f), FLOAT16(41.0f), FLOAT16(42.0f), FLOAT16(43.0f), FLOAT16(44.0f),
FLOAT16(45.0f), FLOAT16(46.0f), FLOAT16(47.0f), FLOAT16(48.0f), FLOAT16(49.0f),
FLOAT16(50.0f), FLOAT16(51.0f), FLOAT16(52.0f), FLOAT16(53.0f), FLOAT16(54.0f),
FLOAT16(55.0f), FLOAT16(56.0f), FLOAT16(57.0f), FLOAT16(58.0f), FLOAT16(59.0f),
FLOAT16(60.0f), FLOAT16(61.0f), FLOAT16(62.0f), FLOAT16(63.0f), FLOAT16(64.0f),
FLOAT16(65.0f), FLOAT16(66.0f), FLOAT16(67.0f), FLOAT16(68.0f), FLOAT16(69.0f),
FLOAT16(70.0f), FLOAT16(71.0f), FLOAT16(72.0f), FLOAT16(73.0f), FLOAT16(74.0f),
FLOAT16(75.0f), FLOAT16(76.0f), FLOAT16(77.0f), FLOAT16(78.0f), FLOAT16(79.0f),
FLOAT16(80.0f)
ov::float16(0.0f), ov::float16(1.0f), ov::float16(2.0f), ov::float16(3.0f), ov::float16(4.0f),
ov::float16(5.0f), ov::float16(6.0f), ov::float16(7.0f), ov::float16(8.0f), ov::float16(9.0f),
ov::float16(10.0f), ov::float16(11.0f), ov::float16(12.0f), ov::float16(13.0f), ov::float16(14.0f),
ov::float16(15.0f), ov::float16(16.0f), ov::float16(17.0f), ov::float16(18.0f), ov::float16(19.0f),
ov::float16(20.0f), ov::float16(21.0f), ov::float16(22.0f), ov::float16(23.0f), ov::float16(24.0f),
ov::float16(25.0f), ov::float16(26.0f), ov::float16(27.0f), ov::float16(28.0f), ov::float16(29.0f),
ov::float16(30.0f), ov::float16(31.0f), ov::float16(32.0f), ov::float16(33.0f), ov::float16(34.0f),
ov::float16(35.0f), ov::float16(36.0f), ov::float16(37.0f), ov::float16(38.0f), ov::float16(39.0f),
ov::float16(40.0f), ov::float16(41.0f), ov::float16(42.0f), ov::float16(43.0f), ov::float16(44.0f),
ov::float16(45.0f), ov::float16(46.0f), ov::float16(47.0f), ov::float16(48.0f), ov::float16(49.0f),
ov::float16(50.0f), ov::float16(51.0f), ov::float16(52.0f), ov::float16(53.0f), ov::float16(54.0f),
ov::float16(55.0f), ov::float16(56.0f), ov::float16(57.0f), ov::float16(58.0f), ov::float16(59.0f),
ov::float16(60.0f), ov::float16(61.0f), ov::float16(62.0f), ov::float16(63.0f), ov::float16(64.0f),
ov::float16(65.0f), ov::float16(66.0f), ov::float16(67.0f), ov::float16(68.0f), ov::float16(69.0f),
ov::float16(70.0f), ov::float16(71.0f), ov::float16(72.0f), ov::float16(73.0f), ov::float16(74.0f),
ov::float16(75.0f), ov::float16(76.0f), ov::float16(77.0f), ov::float16(78.0f), ov::float16(79.0f),
ov::float16(80.0f)
});
topology topology;
@ -212,8 +212,8 @@ TEST(depth_to_space_fp32_gpu, d112960540_bs2) {
auto input1 = engine.allocate_memory({ data_types::f16, format::bfyx, { 1, 12, 960, 540 } });
size_t block_size = 2;
auto random_input = rg.generate_random_4d<FLOAT16>(1, 12, 540, 960, -1, 1);
auto input_rnd_vec = flatten_4d<FLOAT16>(format::bfyx, random_input);
auto random_input = rg.generate_random_4d<ov::float16>(1, 12, 540, 960, -1, 1);
auto input_rnd_vec = flatten_4d<ov::float16>(format::bfyx, random_input);
set_values(input1, input_rnd_vec);
topology topology_act;
@ -229,7 +229,7 @@ TEST(depth_to_space_fp32_gpu, d112960540_bs2) {
auto outputs = network_act.execute();
auto output = outputs.at("depth_to_space").get_memory();
cldnn::mem_lock<FLOAT16> output_ptr (output, get_test_stream());
cldnn::mem_lock<ov::float16> output_ptr (output, get_test_stream());
std::vector<uint16_t> perm = { 0,3,4,1,5,2 };
@ -254,7 +254,7 @@ TEST(depth_to_space_fp32_gpu, d112960540_bs2) {
auto outputs_ref = network_ref.execute();
auto output_ref = outputs_ref.at("reshape2").get_memory();
cldnn::mem_lock<FLOAT16> output_ptr_ref(output_ref, get_test_stream());
cldnn::mem_lock<ov::float16> output_ptr_ref(output_ref, get_test_stream());
for (size_t i = 0; i < output->get_layout().count(); ++i) {
ASSERT_EQ(output_ptr_ref[i], output_ptr[i]);

86
src/plugins/intel_gpu/tests/unit/test_cases/detection_output_test.cpp
View File

@ -137,9 +137,9 @@ public:
const int keep_top_k = 150;
auto& engine = get_test_engine();
cldnn::memory::ptr input_location = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx,{ this->num_of_images, this->num_priors * num_loc_classes * 4, 1, 1 } });
cldnn::memory::ptr input_confidence = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx,{ this->num_of_images, this->num_priors * this->num_classes, 1, 1 } });
cldnn::memory::ptr input_prior_box = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx,{ 1, 2, 1, this->num_priors * 4 } });
cldnn::memory::ptr input_location = engine.allocate_memory({ ov::element::from<T>(), format::bfyx,{ this->num_of_images, this->num_priors * num_loc_classes * 4, 1, 1 } });
cldnn::memory::ptr input_confidence = engine.allocate_memory({ ov::element::from<T>(), format::bfyx,{ this->num_of_images, this->num_priors * this->num_classes, 1, 1 } });
cldnn::memory::ptr input_prior_box = engine.allocate_memory({ ov::element::from<T>(), format::bfyx,{ 1, 2, 1, this->num_priors * 4 } });
topology topology;
topology.add(input_layout("input_location", input_location->get_layout()));
@ -171,9 +171,9 @@ public:
const int keep_top_k = 150;
auto& engine = get_test_engine();
cldnn::memory::ptr input_location = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx,{ this->num_of_images, this->num_priors * num_loc_classes * 4, 1, 1 } });
cldnn::memory::ptr input_confidence = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx,{ this->num_of_images, this->num_priors * this->num_classes, 1, 1 } });
cldnn::memory::ptr input_prior_box = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx,{ 1, 2, 1, this->num_priors * 4 } });
cldnn::memory::ptr input_location = engine.allocate_memory({ ov::element::from<T>(), format::bfyx,{ this->num_of_images, this->num_priors * num_loc_classes * 4, 1, 1 } });
cldnn::memory::ptr input_confidence = engine.allocate_memory({ ov::element::from<T>(), format::bfyx,{ this->num_of_images, this->num_priors * this->num_classes, 1, 1 } });
cldnn::memory::ptr input_prior_box = engine.allocate_memory({ ov::element::from<T>(), format::bfyx,{ 1, 2, 1, this->num_priors * 4 } });
topology topology;
topology.add(input_layout("input_location", input_location->get_layout()));
@ -212,9 +212,9 @@ public:
const int background_label_id = 0;
auto& engine = get_test_engine();
cldnn::memory::ptr input_location = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx,{ this->num_of_images, this->num_priors * num_loc_classes * 4, 1, 1 } });
cldnn::memory::ptr input_confidence = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx,{ this->num_of_images, this->num_priors * this->num_classes, 1, 1 } });
cldnn::memory::ptr input_prior_box = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx,{ 1, 2, 1, this->num_priors * 4 } });
cldnn::memory::ptr input_location = engine.allocate_memory({ ov::element::from<T>(), format::bfyx,{ this->num_of_images, this->num_priors * num_loc_classes * 4, 1, 1 } });
cldnn::memory::ptr input_confidence = engine.allocate_memory({ ov::element::from<T>(), format::bfyx,{ this->num_of_images, this->num_priors * this->num_classes, 1, 1 } });
cldnn::memory::ptr input_prior_box = engine.allocate_memory({ ov::element::from<T>(), format::bfyx,{ 1, 2, 1, this->num_priors * 4 } });
this->init_buffers(input_prior_box, input_confidence, input_location, share_location);
@ -260,9 +260,9 @@ public:
const int background_label_id = 0;
auto& engine = get_test_engine();
cldnn::memory::ptr input_location = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx,{ this->num_of_images, this->num_priors * num_loc_classes * 4, 1, 1 } });
cldnn::memory::ptr input_confidence = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx,{ this->num_of_images, this->num_priors * this->num_classes, 1, 1 } });
cldnn::memory::ptr input_prior_box = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx,{ 1, 2, 1, this->num_priors * 4 } });
cldnn::memory::ptr input_location = engine.allocate_memory({ ov::element::from<T>(), format::bfyx,{ this->num_of_images, this->num_priors * num_loc_classes * 4, 1, 1 } });
cldnn::memory::ptr input_confidence = engine.allocate_memory({ ov::element::from<T>(), format::bfyx,{ this->num_of_images, this->num_priors * this->num_classes, 1, 1 } });
cldnn::memory::ptr input_prior_box = engine.allocate_memory({ ov::element::from<T>(), format::bfyx,{ 1, 2, 1, this->num_priors * 4 } });
this->init_buffers(input_prior_box, input_confidence, input_location, share_location);
@ -302,9 +302,9 @@ public:
const int background_label_id = 0;
auto& engine = get_test_engine();
cldnn::memory::ptr input_location = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx,{ this->num_of_images, this->num_priors * num_loc_classes * 4, 1, 1 } });
cldnn::memory::ptr input_confidence = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx,{ this->num_of_images, this->num_priors * this->num_classes, 1, 1 } });
cldnn::memory::ptr input_prior_box = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx,{ 1, 2, 1, this->num_priors * 4 } });
cldnn::memory::ptr input_location = engine.allocate_memory({ ov::element::from<T>(), format::bfyx,{ this->num_of_images, this->num_priors * num_loc_classes * 4, 1, 1 } });
cldnn::memory::ptr input_confidence = engine.allocate_memory({ ov::element::from<T>(), format::bfyx,{ this->num_of_images, this->num_priors * this->num_classes, 1, 1 } });
cldnn::memory::ptr input_prior_box = engine.allocate_memory({ ov::element::from<T>(), format::bfyx,{ 1, 2, 1, this->num_priors * 4 } });
this->init_buffers(input_prior_box, input_confidence, input_location, share_location);
@ -355,9 +355,9 @@ public:
const int background_label_id = 0;
auto& engine = get_test_engine();
cldnn::memory::ptr input_location = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx,{ this->num_of_images, this->num_priors * num_loc_classes * 4, 1, 1 } });
cldnn::memory::ptr input_confidence = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx,{ this->num_of_images, this->num_priors * this->num_classes, 1, 1 } });
cldnn::memory::ptr input_prior_box = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx,{ 1, 2, 1, this->num_priors * 4 } });
cldnn::memory::ptr input_location = engine.allocate_memory({ ov::element::from<T>(), format::bfyx,{ this->num_of_images, this->num_priors * num_loc_classes * 4, 1, 1 } });
cldnn::memory::ptr input_confidence = engine.allocate_memory({ ov::element::from<T>(), format::bfyx,{ this->num_of_images, this->num_priors * this->num_classes, 1, 1 } });
cldnn::memory::ptr input_prior_box = engine.allocate_memory({ ov::element::from<T>(), format::bfyx,{ 1, 2, 1, this->num_priors * 4 } });
this->init_buffers(input_prior_box, input_confidence, input_location, share_location);
@ -411,11 +411,11 @@ public:
const bool decrease_label_id = true;
auto& engine = get_test_engine();
cldnn::memory::ptr input_location = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx,
cldnn::memory::ptr input_location = engine.allocate_memory({ ov::element::from<T>(), format::bfyx,
{ this->num_of_images, this->num_priors * num_loc_classes * 4, 1, 1 } });
cldnn::memory::ptr input_confidence = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx,
cldnn::memory::ptr input_confidence = engine.allocate_memory({ ov::element::from<T>(), format::bfyx,
{ this->num_of_images, this->num_priors * this->num_classes, 1, 1 } });
cldnn::memory::ptr input_prior_box = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx,
cldnn::memory::ptr input_prior_box = engine.allocate_memory({ ov::element::from<T>(), format::bfyx,
{ 1, 2, 1, this->num_priors * 4 } });
this->init_buffers(input_prior_box, input_confidence, input_location, share_location);
@ -430,7 +430,7 @@ public:
top_k, eta, code_type, variance_encoded_in_target, confidence_threshold, prior_info_size,
prior_coordinates_offset, prior_is_normalized, input_width, input_height, decrease_label_id
));
topology.add(reorder("output_reorder", input_info("detection_output"), format::bfyx, type_to_data_type<T>::value));
topology.add(reorder("output_reorder", input_info("detection_output"), format::bfyx, ov::element::from<T>()));
auto config = get_test_default_config(engine);
config.set_property(ov::intel_gpu::force_implementations(ov::intel_gpu::ImplForcingMap{{"detection_output", {format::bfyx, "", impl_types::cpu}}}));
@ -472,9 +472,9 @@ public:
const int background_label_id = -1;
auto& engine = get_test_engine();
cldnn::memory::ptr input_location = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx,{ this->num_of_images, this->num_priors * num_loc_classes * 4, 1, 1 } });
cldnn::memory::ptr input_confidence = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx,{ this->num_of_images, this->num_priors * this->num_classes, 1, 1 } });
cldnn::memory::ptr input_prior_box = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx,{ 1, 2, 1, this->num_priors * 4 } });
cldnn::memory::ptr input_location = engine.allocate_memory({ ov::element::from<T>(), format::bfyx,{ this->num_of_images, this->num_priors * num_loc_classes * 4, 1, 1 } });
cldnn::memory::ptr input_confidence = engine.allocate_memory({ ov::element::from<T>(), format::bfyx,{ this->num_of_images, this->num_priors * this->num_classes, 1, 1 } });
cldnn::memory::ptr input_prior_box = engine.allocate_memory({ ov::element::from<T>(), format::bfyx,{ 1, 2, 1, this->num_priors * 4 } });
this->init_buffers(input_prior_box, input_confidence, input_location, share_location);
@ -533,9 +533,9 @@ public:
const int top_k = 2;
auto& engine = get_test_engine();
cldnn::memory::ptr input_location = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx,{ this->num_of_images, this->num_priors * num_loc_classes * 4, 1, 1 } });
cldnn::memory::ptr input_confidence = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx,{ this->num_of_images, this->num_priors * this->num_classes, 1, 1 } });
cldnn::memory::ptr input_prior_box = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx,{ 1, 2, 1, this->num_priors * 4 } });
cldnn::memory::ptr input_location = engine.allocate_memory({ ov::element::from<T>(), format::bfyx,{ this->num_of_images, this->num_priors * num_loc_classes * 4, 1, 1 } });
cldnn::memory::ptr input_confidence = engine.allocate_memory({ ov::element::from<T>(), format::bfyx,{ this->num_of_images, this->num_priors * this->num_classes, 1, 1 } });
cldnn::memory::ptr input_prior_box = engine.allocate_memory({ ov::element::from<T>(), format::bfyx,{ 1, 2, 1, this->num_priors * 4 } });
this->init_buffers(input_prior_box, input_confidence, input_location, share_location);
@ -581,9 +581,9 @@ public:
const int background_label_id = 0;
auto& engine = get_test_engine();
cldnn::memory::ptr input_location = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx,{ this->num_of_images, this->num_priors * num_loc_classes * 4, 1, 1 } });
cldnn::memory::ptr input_confidence = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx,{ this->num_of_images, this->num_priors * this->num_classes, 1, 1 } });
cldnn::memory::ptr input_prior_box = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx,{ 1, 2, 1, this->num_priors * 4 } });
cldnn::memory::ptr input_location = engine.allocate_memory({ ov::element::from<T>(), format::bfyx,{ this->num_of_images, this->num_priors * num_loc_classes * 4, 1, 1 } });
cldnn::memory::ptr input_confidence = engine.allocate_memory({ ov::element::from<T>(), format::bfyx,{ this->num_of_images, this->num_priors * this->num_classes, 1, 1 } });
cldnn::memory::ptr input_prior_box = engine.allocate_memory({ ov::element::from<T>(), format::bfyx,{ 1, 2, 1, this->num_priors * 4 } });
this->init_buffers(input_prior_box, input_confidence, input_location, share_location);
@ -632,9 +632,9 @@ public:
const int top_k = 2;
auto& engine = get_test_engine();
cldnn::memory::ptr input_location = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx,{ this->num_of_images, this->num_priors * num_loc_classes * 4, 1, 1 } });
cldnn::memory::ptr input_confidence = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx,{ this->num_of_images, this->num_priors * this->num_classes, 1, 1 } });
cldnn::memory::ptr input_prior_box = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx,{ 1, 2, 1, this->num_priors * 4 } });
cldnn::memory::ptr input_location = engine.allocate_memory({ ov::element::from<T>(), format::bfyx,{ this->num_of_images, this->num_priors * num_loc_classes * 4, 1, 1 } });
cldnn::memory::ptr input_confidence = engine.allocate_memory({ ov::element::from<T>(), format::bfyx,{ this->num_of_images, this->num_priors * this->num_classes, 1, 1 } });
cldnn::memory::ptr input_prior_box = engine.allocate_memory({ ov::element::from<T>(), format::bfyx,{ 1, 2, 1, this->num_priors * 4 } });
this->init_buffers(input_prior_box, input_confidence, input_location, share_location);
@ -677,9 +677,9 @@ public:
const int top_k = 2;
auto& engine = get_test_engine();
cldnn::memory::ptr input_location = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx,{ this->num_of_images, this->num_priors * num_loc_classes * 4, 1, 1 } });
cldnn::memory::ptr input_confidence = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx,{ this->num_of_images, this->num_priors * this->num_classes, 1, 1 } });
cldnn::memory::ptr input_prior_box = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx,{ 1, 2, 1, this->num_priors * 4 } });
cldnn::memory::ptr input_location = engine.allocate_memory({ ov::element::from<T>(), format::bfyx,{ this->num_of_images, this->num_priors * num_loc_classes * 4, 1, 1 } });
cldnn::memory::ptr input_confidence = engine.allocate_memory({ ov::element::from<T>(), format::bfyx,{ this->num_of_images, this->num_priors * this->num_classes, 1, 1 } });
cldnn::memory::ptr input_prior_box = engine.allocate_memory({ ov::element::from<T>(), format::bfyx,{ 1, 2, 1, this->num_priors * 4 } });
this->init_buffers(input_prior_box, input_confidence, input_location, share_location);
topology topology;
@ -690,7 +690,7 @@ public:
topology.add(reorder("input_confidence_padded", input_info("input_confidence"), input_location->get_layout().with_padding(padding{ { 0, 0, 2, 7 },{ 0, 0, 13, 1 } })));
topology.add(detection_output("detection_output", { input_info("input_location_padded"), input_info("input_confidence_padded"), input_info("input_prior_box") }, this->num_classes, keep_top_k, share_location, background_label_id, this->nms_threshold, top_k));
topology.add(reorder("output_reorder", input_info("detection_output"), format::bfyx, type_to_data_type<T>::value));
topology.add(reorder("output_reorder", input_info("detection_output"), format::bfyx, ov::element::from<T>()));
auto config = get_test_default_config(engine);
config.set_property(ov::intel_gpu::force_implementations(ov::intel_gpu::ImplForcingMap{{"detection_output", {format::bfyx, "", impl_types::cpu}}}));
@ -738,9 +738,9 @@ public:
const bool prior_is_normalized = true;
auto& engine = get_test_engine();
cldnn::memory::ptr input_location = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx,{ this->num_of_images, this->num_priors * num_loc_classes * 4, 1, 1 } });
cldnn::memory::ptr input_confidence = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx,{ this->num_of_images, this->num_priors * this->num_classes, 1, 1 } });
cldnn::memory::ptr input_prior_box = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx,{ 1, 1, 1, this->num_priors * prior_info_size } });
cldnn::memory::ptr input_location = engine.allocate_memory({ ov::element::from<T>(), format::bfyx,{ this->num_of_images, this->num_priors * num_loc_classes * 4, 1, 1 } });
cldnn::memory::ptr input_confidence = engine.allocate_memory({ ov::element::from<T>(), format::bfyx,{ this->num_of_images, this->num_priors * this->num_classes, 1, 1 } });
cldnn::memory::ptr input_prior_box = engine.allocate_memory({ ov::element::from<T>(), format::bfyx,{ 1, 1, 1, this->num_priors * prior_info_size } });
this->init_buffers(input_prior_box, input_confidence, input_location, share_location, variance_encoded_in_target,
prior_info_size, prior_coordinates_offset, prior_is_normalized);
@ -751,7 +751,7 @@ public:
topology.add(input_layout("input_prior_box", input_prior_box->get_layout()));
topology.add(reorder("input_location_padded", input_info("input_location"), input_location->get_layout().with_padding(padding{ { 0, 0, 12, 3 },{ 0, 0, 5, 11 } })));
topology.add(reorder("input_confidence_padded", input_info("input_confidence"), input_location->get_layout().with_padding(padding{ { 0, 0, 2, 7 },{ 0, 0, 13, 1 } })));
topology.add(reorder("output_reorder", input_info("detection_output"), format::bfyx, type_to_data_type<T>::value));
topology.add(reorder("output_reorder", input_info("detection_output"), format::bfyx, ov::element::from<T>()));
topology.add(detection_output("detection_output", { input_info("input_location_padded"), input_info("input_confidence_padded"), input_info("input_prior_box") },
this->num_classes, keep_top_k, share_location, background_label_id, this->nms_threshold, top_k,
@ -797,7 +797,7 @@ public:
const float nms_threshold;
};
typedef ::testing::Types<float, FLOAT16> detection_output_test_types;
typedef ::testing::Types<float, ov::float16> detection_output_test_types;
TYPED_TEST_SUITE(detection_output_test, detection_output_test_types);
TYPED_TEST(detection_output_test, test_setup_basic) {

15
src/plugins/intel_gpu/tests/unit/test_cases/dft_gpu_test.cpp
View File

@ -61,7 +61,7 @@ float getThreshold<float>(dft_type type) {
}
template <>
float getThreshold<half_t>(dft_type type) {
float getThreshold<ov::float16>(dft_type type) {
if (type.direction == dft_direction::forward && type.mode == dft_mode::complex) {
return 4e-2f;
}
@ -106,7 +106,7 @@ public:
auto& engine = get_test_engine();
auto data_type = type_to_data_type<T>::value;
auto data_type = ov::element::from<T>();
const layout data_layout(data_type, plain_format, tensor(plain_format, p.input_shape));
auto input = engine.allocate_memory(data_layout);
set_values(input, convert<T>(p.input_values));
@ -146,7 +146,7 @@ public:
std::ostringstream result;
result << "InputShape=" << vec2str(p.input_shape) << "_";
result << "Precision=" << data_type_traits::name(type_to_data_type<T>::value) << "_";
result << "Precision=" << ov::element::Type(ov::element::from<T>()) << "_";
result << "Axes=" << vec2str(p.axes) << "_";
result << "SignalSize=" << vec2str(p.signal_size) << "_";
result << "Inverse=" << (type.direction == dft_direction::inverse) << "_";
@ -1990,13 +1990,13 @@ const std::vector<format> blocked_format_5d = {
};
using dft_gpu_test_float = dft_gpu_test<float>;
using dft_gpu_test_half_t = dft_gpu_test<half_t>;
using dft_gpu_test_float16 = dft_gpu_test<ov::float16>;
TEST_P(dft_gpu_test_float, test) {
ASSERT_NO_FATAL_FAILURE(test());
}
TEST_P(dft_gpu_test_half_t, test) {
TEST_P(dft_gpu_test_float16, test) {
ASSERT_NO_FATAL_FAILURE(test());
}
@ -2010,9 +2010,10 @@ TEST_P(dft_gpu_test_half_t, test) {
testing::Values(false)), \
dft_gpu_test_##inputType::PrintToStringParamName);
using ov::float16;
#define INSTANTIATE_DFT_TEST_SUITE_WITH_TYPES(dftType, dimension) \
INSTANTIATE_DFT_TEST_SUITE(dftType, dimension, float) \
INSTANTIATE_DFT_TEST_SUITE(dftType, dimension, half_t)
INSTANTIATE_DFT_TEST_SUITE(dftType, dimension, float16)
INSTANTIATE_DFT_TEST_SUITE_WITH_TYPES(DFT, 4d)
INSTANTIATE_DFT_TEST_SUITE_WITH_TYPES(DFT, 5d)
@ -2042,7 +2043,7 @@ TEST(dft_gpu_test, irdft_output_shape) {
dft_params p = IRDFT_params_5d.front();
auto& engine = get_test_engine();
auto data_type = type_to_data_type<T>::value;
auto data_type = ov::element::from<T>();
const layout data_layout(data_type, plain_format_5d, tensor(plain_format_5d, p.input_shape));
auto input = engine.allocate_memory(data_layout);
set_values(input, convert<T>(p.input_values));

88
src/plugins/intel_gpu/tests/unit/test_cases/eltwise_gpu_test.cpp
View File

@ -89,8 +89,8 @@ void generic_eltwise_test(cldnn::format test_input_fmt, int input_b, int input_f
auto& engine = get_test_engine();
tensor input_tensor( input_b, input_f, input_x, input_y );
auto input1 = engine.allocate_memory({ type_to_data_type<T>::value, test_input_fmt, input_tensor });
auto input2 = engine.allocate_memory({ type_to_data_type<T>::value, test_input_fmt, input_tensor });
auto input1 = engine.allocate_memory({ ov::element::from<T>(), test_input_fmt, input_tensor });
auto input2 = engine.allocate_memory({ ov::element::from<T>(), test_input_fmt, input_tensor });
set_values(input1, input1_rnd_vec);
set_values(input2, input2_rnd_vec);
@ -164,7 +164,7 @@ void run_eltwise_generic_test(cldnn::eltwise_mode mode) {
generic_eltwise_test<float>(test_inputs_fmt, 1, 1, input_size.first, input_size.second, mode, false, 0.f, 0, 0, 0, 0);
if (f16_supported)
generic_eltwise_test<FLOAT16>(test_inputs_fmt, 1, 1, input_size.first, input_size.second, mode, false, (FLOAT16)0.f, 0, 0, 0, 0);
generic_eltwise_test<ov::float16>(test_inputs_fmt, 1, 1, input_size.first, input_size.second, mode, false, (ov::float16)0.f, 0, 0, 0, 0);
}
@ -233,8 +233,8 @@ void generic_eltwise_bool_test(cldnn::format test_input_fmt, int input_b, int in
auto& engine = get_test_engine();
tensor input_tensor( input_b, input_f, input_x, input_y );
auto input1 = engine.allocate_memory({ type_to_data_type<T>::value, test_input_fmt, input_tensor });
auto input2 = engine.allocate_memory({ type_to_data_type<T>::value, test_input_fmt, input_tensor });
auto input1 = engine.allocate_memory({ ov::element::from<T>(), test_input_fmt, input_tensor });
auto input2 = engine.allocate_memory({ ov::element::from<T>(), test_input_fmt, input_tensor });
set_values(input1, input1_rnd_vec);
set_values(input2, input2_rnd_vec);
@ -3194,10 +3194,10 @@ TEST(eltwise_gpu_f16, fs_b_yx_fsv32_basic)
tensor input_tensor(2, 2, 2, 2);
auto fp16_bfyx_2x2x2x2_input =
{
FLOAT16(1111),FLOAT16(1112),FLOAT16(1121),FLOAT16(1122),
FLOAT16(1211),FLOAT16(1212),FLOAT16(1221),FLOAT16(1222),
FLOAT16(2111),FLOAT16(2112),FLOAT16(2121),FLOAT16(2122),
FLOAT16(2211),FLOAT16(2212),FLOAT16(2221),FLOAT16(2222)
ov::float16(1111),ov::float16(1112),ov::float16(1121),ov::float16(1122),
ov::float16(1211),ov::float16(1212),ov::float16(1221),ov::float16(1222),
ov::float16(2111),ov::float16(2112),ov::float16(2121),ov::float16(2122),
ov::float16(2211),ov::float16(2212),ov::float16(2221),ov::float16(2222)
};
auto& engine = get_test_engine();
@ -3225,7 +3225,7 @@ TEST(eltwise_gpu_f16, fs_b_yx_fsv32_basic)
auto golden_outputs = golden_network.execute();
auto golden_output = golden_outputs.at("eltwise").get_memory();
cldnn::mem_lock<FLOAT16> golden_ptr(golden_output, get_test_stream());
cldnn::mem_lock<ov::float16> golden_ptr(golden_output, get_test_stream());
// GOLDEN BFYX ELTWISE - END
// FS_B_YX_FSV32 ELTWISE
topology FSV32_topology;
@ -3242,7 +3242,7 @@ TEST(eltwise_gpu_f16, fs_b_yx_fsv32_basic)
auto FSV32_outputs = FSV32_network.execute();
auto FSV32_output = FSV32_outputs.at("reorderOutput").get_memory();
cldnn::mem_lock<FLOAT16> FSV32_ptr(FSV32_output, get_test_stream());
cldnn::mem_lock<ov::float16> FSV32_ptr(FSV32_output, get_test_stream());
// FS_B_YX_FSV32 ELTWISE - END
ASSERT_EQ(golden_ptr.size(), FSV32_ptr.size());
@ -3270,11 +3270,11 @@ TEST(eltwise_gpu_f16, fs_b_yx_fsv32_broadcast)
tensor input1_tensor(input_b, input_f, input1_x, input1_y);
tensor input2_tensor(input_b, input_f, input2_x, input2_y);
VVVVF<FLOAT16> input1_rnd = rg.generate_random_4d<FLOAT16>(input_b, input_f, input1_y, input1_x, 1, 3);
VVVVF<FLOAT16> input2_rnd = rg.generate_random_4d<FLOAT16>(input_b, input_f, input2_y, input2_x, 1, 3);
VVVVF<ov::float16> input1_rnd = rg.generate_random_4d<ov::float16>(input_b, input_f, input1_y, input1_x, 1, 3);
VVVVF<ov::float16> input2_rnd = rg.generate_random_4d<ov::float16>(input_b, input_f, input2_y, input2_x, 1, 3);
VF<FLOAT16> input1_flatten = flatten_4d<FLOAT16>(format::bfyx, input1_rnd);
VF<FLOAT16> input2_flatten = flatten_4d<FLOAT16>(format::bfyx, input2_rnd);
VF<ov::float16> input1_flatten = flatten_4d<ov::float16>(format::bfyx, input1_rnd);
VF<ov::float16> input2_flatten = flatten_4d<ov::float16>(format::bfyx, input2_rnd);
auto input1 = engine.allocate_memory({ data_types::f16,format::bfyx, input1_tensor });
auto input2 = engine.allocate_memory({ data_types::f16,format::bfyx, input2_tensor });
@ -3293,7 +3293,7 @@ TEST(eltwise_gpu_f16, fs_b_yx_fsv32_broadcast)
auto ref_outputs = ref_network.execute();
auto ref_output = ref_outputs.at("eltwise").get_memory();
cldnn::mem_lock<FLOAT16> ref_ptr(ref_output, get_test_stream());
cldnn::mem_lock<ov::float16> ref_ptr(ref_output, get_test_stream());
topology fsv32_topology;
fsv32_topology.add(input_layout("input1", input1->get_layout()));
@ -3309,7 +3309,7 @@ TEST(eltwise_gpu_f16, fs_b_yx_fsv32_broadcast)
auto fsv32_outputs = fsv32_network.execute();
auto fsv32_output = fsv32_outputs.at("reorder_bfyx").get_memory();
cldnn::mem_lock<FLOAT16> fsv32_ptr(fsv32_output, get_test_stream());
cldnn::mem_lock<ov::float16> fsv32_ptr(fsv32_output, get_test_stream());
ASSERT_EQ(ref_ptr.size(), fsv32_ptr.size());
@ -3335,11 +3335,11 @@ TEST(eltwise_gpu_f16, fs_b_yx_fsv32_broadcast_bfyx)
tensor input1_tensor(input_b, input_f, input1_x, input1_y);
tensor input2_tensor(1, input_f, 1, 1);
VVVVF<FLOAT16> input1_rnd = rg.generate_random_4d<FLOAT16>(input_b, input_f, input1_y, input1_x, 1, 3);
VVVVF<FLOAT16> input2_rnd = rg.generate_random_4d<FLOAT16>(1, input_f, 1, 1, 1, 3);
VVVVF<ov::float16> input1_rnd = rg.generate_random_4d<ov::float16>(input_b, input_f, input1_y, input1_x, 1, 3);
VVVVF<ov::float16> input2_rnd = rg.generate_random_4d<ov::float16>(1, input_f, 1, 1, 1, 3);
VF<FLOAT16> input1_flatten = flatten_4d<FLOAT16>(format::bfyx, input1_rnd);
VF<FLOAT16> input2_flatten = flatten_4d<FLOAT16>(format::bfyx, input2_rnd);
VF<ov::float16> input1_flatten = flatten_4d<ov::float16>(format::bfyx, input1_rnd);
VF<ov::float16> input2_flatten = flatten_4d<ov::float16>(format::bfyx, input2_rnd);
auto input1 = engine.allocate_memory({ data_types::f16, format::bfyx, input1_tensor });
auto input2 = engine.allocate_memory({ data_types::f16, format::bfyx, input2_tensor });
@ -3358,7 +3358,7 @@ TEST(eltwise_gpu_f16, fs_b_yx_fsv32_broadcast_bfyx)
auto ref_outputs = ref_network.execute();
auto ref_output = ref_outputs.at("eltwise").get_memory();
cldnn::mem_lock<FLOAT16> ref_ptr(ref_output, get_test_stream());
cldnn::mem_lock<ov::float16> ref_ptr(ref_output, get_test_stream());
topology fsv32_topology;
fsv32_topology.add(input_layout("input1", input1->get_layout()));
@ -3373,7 +3373,7 @@ TEST(eltwise_gpu_f16, fs_b_yx_fsv32_broadcast_bfyx)
auto fsv32_outputs = fsv32_network.execute();
auto fsv32_output = fsv32_outputs.at("reorder_bfyx").get_memory();
cldnn::mem_lock<FLOAT16> fsv32_ptr(fsv32_output, get_test_stream());
cldnn::mem_lock<ov::float16> fsv32_ptr(fsv32_output, get_test_stream());
ASSERT_EQ(ref_ptr.size(), fsv32_ptr.size());
@ -3441,8 +3441,8 @@ TEST(eltwise_gpu_f16, bfyx_and_fs_b_yx_fsv32_basic)
// Inputs are 32x96x2x2
tests::random_generator rg(GET_SUITE_NAME);
tensor input_tensor(32, 96, 20, 20);
VVVVF<FLOAT16> input_rnd = rg.generate_random_4d<FLOAT16>(32, 96, 20, 20, 1, 3);
VF<FLOAT16> fp16_bfyx_32x96x2x2_input = flatten_4d<FLOAT16>(format::bfyx, input_rnd);
VVVVF<ov::float16> input_rnd = rg.generate_random_4d<ov::float16>(32, 96, 20, 20, 1, 3);
VF<ov::float16> fp16_bfyx_32x96x2x2_input = flatten_4d<ov::float16>(format::bfyx, input_rnd);
auto& engine = get_test_engine();
bool f16_supported = engine.get_device_info().supports_fp16;
@ -3469,7 +3469,7 @@ TEST(eltwise_gpu_f16, bfyx_and_fs_b_yx_fsv32_basic)
auto golden_outputs = golden_network.execute();
auto golden_output = golden_outputs.at("eltwise").get_memory();
cldnn::mem_lock<FLOAT16> golden_ptr(golden_output, get_test_stream());
cldnn::mem_lock<ov::float16> golden_ptr(golden_output, get_test_stream());
// GOLDEN BFYX ELTWISE - END
// MIXED INPUT, FS_B_YX_FSV32 OUTPUT
topology FS_B_YX_FSV32_OUTPUT_topology;
@ -3486,7 +3486,7 @@ TEST(eltwise_gpu_f16, bfyx_and_fs_b_yx_fsv32_basic)
auto FS_B_YX_FSV32_OUTPUT_outputs = FS_B_YX_FSV32_OUTPUT_network.execute();
auto FS_B_YX_FSV32_OUTPUT_output = FS_B_YX_FSV32_OUTPUT_outputs.at("reorderOutput").get_memory();
cldnn::mem_lock<FLOAT16> FS_B_YX_FSV32_OUTPUT_ptr(FS_B_YX_FSV32_OUTPUT_output, get_test_stream());
cldnn::mem_lock<ov::float16> FS_B_YX_FSV32_OUTPUT_ptr(FS_B_YX_FSV32_OUTPUT_output, get_test_stream());
// MIXED INPUT, FS_B_YX_FSV32 OUTPUT - END
// MIXED INPUT, BYXF OUTPUT
topology BYXF_OUTPUT_topology;
@ -3503,7 +3503,7 @@ TEST(eltwise_gpu_f16, bfyx_and_fs_b_yx_fsv32_basic)
auto BYXF_OUTPUT_outputs = BYXF_OUTPUT_network.execute();
auto BYXF_OUTPUT_output = BYXF_OUTPUT_outputs.at("reorderOutput").get_memory();
cldnn::mem_lock<FLOAT16> BYXF_OUTPUT_ptr(BYXF_OUTPUT_output, get_test_stream());
cldnn::mem_lock<ov::float16> BYXF_OUTPUT_ptr(BYXF_OUTPUT_output, get_test_stream());
// MIXED INPUT, BYXF OUTPUT - END
ASSERT_EQ(golden_ptr.size(), FS_B_YX_FSV32_OUTPUT_ptr.size());
@ -3521,8 +3521,8 @@ TEST(eltwise_gpu_f16, bfyx_and_fs_b_yx_fsv32_output_padding) {
// Inputs are 32x96x2x2
tests::random_generator rg(GET_SUITE_NAME);
tensor input_tensor(32, 96, 20, 20);
VVVVF<FLOAT16> input_rnd = rg.generate_random_4d<FLOAT16>(32, 96, 20, 20, 1, 3);
VF<FLOAT16> fp16_bfyx_32x96x2x2_input = flatten_4d<FLOAT16>(format::bfyx, input_rnd);
VVVVF<ov::float16> input_rnd = rg.generate_random_4d<ov::float16>(32, 96, 20, 20, 1, 3);
VF<ov::float16> fp16_bfyx_32x96x2x2_input = flatten_4d<ov::float16>(format::bfyx, input_rnd);
auto& engine = get_test_engine();
bool f16_supported = engine.get_device_info().supports_fp16;
@ -3549,7 +3549,7 @@ TEST(eltwise_gpu_f16, bfyx_and_fs_b_yx_fsv32_output_padding) {
auto golden_outputs = golden_network.execute();
auto golden_output = golden_outputs.at("eltwise").get_memory();
cldnn::mem_lock<FLOAT16> golden_ptr(golden_output, get_test_stream());
cldnn::mem_lock<ov::float16> golden_ptr(golden_output, get_test_stream());
// GOLDEN BFYX ELTWISE - END
// MIXED INPUT, FS_B_YX_FSV32 OUTPUT
topology FS_B_YX_FSV32_OUTPUT_topology;
@ -3567,7 +3567,7 @@ TEST(eltwise_gpu_f16, bfyx_and_fs_b_yx_fsv32_output_padding) {
auto FS_B_YX_FSV32_OUTPUT_outputs = FS_B_YX_FSV32_OUTPUT_network.execute();
auto FS_B_YX_FSV32_OUTPUT_output = FS_B_YX_FSV32_OUTPUT_outputs.at("reorderOutput").get_memory();
cldnn::mem_lock<FLOAT16> FS_B_YX_FSV32_OUTPUT_ptr(FS_B_YX_FSV32_OUTPUT_output, get_test_stream());
cldnn::mem_lock<ov::float16> FS_B_YX_FSV32_OUTPUT_ptr(FS_B_YX_FSV32_OUTPUT_output, get_test_stream());
// MIXED INPUT, FS_B_YX_FSV32 OUTPUT - END
// MIXED INPUT, BYXF OUTPUT
topology BYXF_OUTPUT_topology;
@ -3585,7 +3585,7 @@ TEST(eltwise_gpu_f16, bfyx_and_fs_b_yx_fsv32_output_padding) {
auto BYXF_OUTPUT_outputs = BYXF_OUTPUT_network.execute();
auto BYXF_OUTPUT_output = BYXF_OUTPUT_outputs.at("reorderOutput").get_memory();
cldnn::mem_lock<FLOAT16> BYXF_OUTPUT_ptr(BYXF_OUTPUT_output, get_test_stream());
cldnn::mem_lock<ov::float16> BYXF_OUTPUT_ptr(BYXF_OUTPUT_output, get_test_stream());
// MIXED INPUT, BYXF OUTPUT - END
ASSERT_EQ(golden_ptr.size(), FS_B_YX_FSV32_OUTPUT_ptr.size());
@ -3604,8 +3604,8 @@ TEST(eltwise_gpu_f16, bfyx_and_fs_b_yx_fsv32_input_padding)
// Inputs are 32x96x20x20
tests::random_generator rg(GET_SUITE_NAME);
tensor input_tensor(32, 96, 20, 20);
VVVVF<FLOAT16> input_rnd = rg.generate_random_4d<FLOAT16>(32, 96, 20, 20, 1, 3);
VF<FLOAT16> fp16_bfyx_32x96x2x2_input = flatten_4d<FLOAT16>(format::bfyx, input_rnd);
VVVVF<ov::float16> input_rnd = rg.generate_random_4d<ov::float16>(32, 96, 20, 20, 1, 3);
VF<ov::float16> fp16_bfyx_32x96x2x2_input = flatten_4d<ov::float16>(format::bfyx, input_rnd);
auto& engine = get_test_engine();
bool f16_supported = engine.get_device_info().supports_fp16;
@ -3634,7 +3634,7 @@ TEST(eltwise_gpu_f16, bfyx_and_fs_b_yx_fsv32_input_padding)
auto golden_outputs = golden_network.execute();
auto golden_output = golden_outputs.at("eltwise").get_memory();
cldnn::mem_lock<FLOAT16> golden_ptr(golden_output, get_test_stream());
cldnn::mem_lock<ov::float16> golden_ptr(golden_output, get_test_stream());
// GOLDEN BFYX ELTWISE - END
// MIXED INPUT, FS_B_YX_FSV32 OUTPUT
topology FS_B_YX_FSV32_OUTPUT_topology;
@ -3651,7 +3651,7 @@ TEST(eltwise_gpu_f16, bfyx_and_fs_b_yx_fsv32_input_padding)
auto FS_B_YX_FSV32_OUTPUT_outputs = FS_B_YX_FSV32_OUTPUT_network.execute();
auto FS_B_YX_FSV32_OUTPUT_output = FS_B_YX_FSV32_OUTPUT_outputs.at("reorderOutput").get_memory();
cldnn::mem_lock<FLOAT16> FS_B_YX_FSV32_OUTPUT_ptr(FS_B_YX_FSV32_OUTPUT_output, get_test_stream());
cldnn::mem_lock<ov::float16> FS_B_YX_FSV32_OUTPUT_ptr(FS_B_YX_FSV32_OUTPUT_output, get_test_stream());
// MIXED INPUT, FS_B_YX_FSV32 OUTPUT - END
// MIXED INPUT, BYXF OUTPUT
topology BYXF_OUTPUT_topology;
@ -3668,7 +3668,7 @@ TEST(eltwise_gpu_f16, bfyx_and_fs_b_yx_fsv32_input_padding)
auto BYXF_OUTPUT_outputs = BYXF_OUTPUT_network.execute();
auto BYXF_OUTPUT_output = BYXF_OUTPUT_outputs.at("reorderOutput").get_memory();
cldnn::mem_lock<FLOAT16> BYXF_OUTPUT_ptr(BYXF_OUTPUT_output, get_test_stream());
cldnn::mem_lock<ov::float16> BYXF_OUTPUT_ptr(BYXF_OUTPUT_output, get_test_stream());
// MIXED INPUT, BYXF OUTPUT - END
ASSERT_EQ(golden_ptr.size(), FS_B_YX_FSV32_OUTPUT_ptr.size());
@ -3899,7 +3899,7 @@ TEST(DISABLED_eltwise_gpu, generic_random) {
for (int output_padding_x = 0; output_padding_x <= 1; ++output_padding_x) {
generic_eltwise_test<float>(test_input_fmt, input_b, input_f, input_yx.first, input_yx.second, mode, relu_activated, slope, input_padding_y, input_padding_x, output_padding_y, output_padding_x);
if (!f16_supported) continue;
generic_eltwise_test<FLOAT16>(test_input_fmt, input_b, input_f, input_yx.first, input_yx.second, mode, relu_activated, (FLOAT16)slope, input_padding_y, input_padding_x, output_padding_y, output_padding_x);
generic_eltwise_test<ov::float16>(test_input_fmt, input_b, input_f, input_yx.first, input_yx.second, mode, relu_activated, (ov::float16)slope, input_padding_y, input_padding_x, output_padding_y, output_padding_x);
}
}
}
@ -3960,7 +3960,7 @@ struct eltwise_same_input_test : testing::TestWithParam<eltwise_same_input_test_
fill_random_typed<float>(mem, -127, 127, 2);
break;
case data_types::f16:
fill_random_typed<FLOAT16>(mem, -127, 127, 2);
fill_random_typed<ov::float16>(mem, -127, 127, 2);
break;
case data_types::i8:
fill_random_typed<int8_t>(mem, -127, 127, 1);
@ -4031,7 +4031,7 @@ struct eltwise_same_input_test : testing::TestWithParam<eltwise_same_input_test_
if (params.input_type == data_types::f32) {
compare_outputs<float>(output, input);
} else if (params.input_type == data_types::f16) {
compare_outputs<FLOAT16>(output, input);
compare_outputs<ov::float16>(output, input);
} else if (params.input_type == data_types::i8) {
compare_outputs<int8_t>(output, input);
} else if (params.input_type == data_types::u8) {
@ -4536,7 +4536,7 @@ struct eltwise_random_test : testing::TestWithParam<eltwise_random_test_params>
}
static std::string PrintToString(const eltwise_random_test_params& params) {
std::string res = " data (" + cldnn::data_type_traits::name(params.input_type) + "), ";
std::string res = " data (" + ov::element::Type(params.input_type).get_type_name() + "), ";
res += " format (" + format::traits(params.in_format).str + ") input1 : ";
res += params.first_input_size.to_string() + " / input2 : ";
res += params.second_input_size.to_string() + "\n";
@ -4574,7 +4574,7 @@ struct eltwise_random_test : testing::TestWithParam<eltwise_random_test_params>
fill_random_typed<float>(mem, -127, 127, 2);
break;
case data_types::f16:
fill_random_typed<FLOAT16>(mem, -127, 127, 2);
fill_random_typed<ov::float16>(mem, -127, 127, 2);
break;
case data_types::i8:
fill_random_typed<int8_t>(mem, -127, 127, 1);
@ -4670,7 +4670,7 @@ struct eltwise_random_test : testing::TestWithParam<eltwise_random_test_params>
if (params.input_type == data_types::f32) {
compare_outputs<float>(output, output_opt);
} else if (params.input_type == data_types::f16) {
compare_outputs<FLOAT16>(output, output_opt);
compare_outputs<ov::float16>(output, output_opt);
} else if (params.input_type == data_types::i8) {
compare_outputs<int8_t>(output, output_opt);
} else if (params.input_type == data_types::u8) {

208
src/plugins/intel_gpu/tests/unit/test_cases/embedding_bag_gpu_test.cpp
View File

@ -27,11 +27,11 @@ TEST(embedding_bag_fp16_gpu, packed_sum_basic) {
tensor output_shape = {3, 2, 1, 1};
set_values(emb_table, {
FLOAT16(-0.2f), FLOAT16(-0.6f),
FLOAT16(-0.1f), FLOAT16(-0.4f),
FLOAT16(-1.9f), FLOAT16(-1.8f),
FLOAT16(-1.0f), FLOAT16(1.5f),
FLOAT16(0.8f), FLOAT16(-0.7f)
ov::float16(-0.2f), ov::float16(-0.6f),
ov::float16(-0.1f), ov::float16(-0.4f),
ov::float16(-1.9f), ov::float16(-1.8f),
ov::float16(-1.0f), ov::float16(1.5f),
ov::float16(0.8f), ov::float16(-0.7f)
});
set_values<int32_t>(indices, {
0, 2,
@ -39,9 +39,9 @@ TEST(embedding_bag_fp16_gpu, packed_sum_basic) {
3, 4
});
set_values(per_sample_weights, {
FLOAT16(0.5f), FLOAT16(0.5f),
FLOAT16(0.5f), FLOAT16(0.5f),
FLOAT16(0.5f), FLOAT16(0.5f)
ov::float16(0.5f), ov::float16(0.5f),
ov::float16(0.5f), ov::float16(0.5f),
ov::float16(0.5f), ov::float16(0.5f)
});
auto type = embedding_bag::packed_sum;
@ -86,11 +86,11 @@ TEST(embedding_bag_fp16_gpu, packed_sum_basic_without_weights) {
tensor output_shape = {3, 2, 1, 1};
set_values(emb_table, {
FLOAT16(-0.2f), FLOAT16(-0.6f),
FLOAT16(-0.1f), FLOAT16(-0.4f),
FLOAT16(-1.9f), FLOAT16(-1.8f),
FLOAT16(-1.0f), FLOAT16(1.5f),
FLOAT16(0.8f), FLOAT16(-0.7f)
ov::float16(-0.2f), ov::float16(-0.6f),
ov::float16(-0.1f), ov::float16(-0.4f),
ov::float16(-1.9f), ov::float16(-1.8f),
ov::float16(-1.0f), ov::float16(1.5f),
ov::float16(0.8f), ov::float16(-0.7f)
});
set_values<int32_t>(indices, {
0, 2,
@ -161,11 +161,11 @@ TEST(embedding_bag_fp16_gpu, packed_sum_dim2) {
* ]
*/
set_values(emb_table, {
FLOAT16(-0.2f), FLOAT16( 1.3f), FLOAT16( 0.5f), FLOAT16(-0.3f),
FLOAT16( 2.3f), FLOAT16( 1.3f), FLOAT16(-0.4f), FLOAT16(-0.7f),
FLOAT16( 3.3f), FLOAT16(-4.1f), FLOAT16( 2.1f), FLOAT16( 0.8f),
FLOAT16( 3.5f), FLOAT16(-5.7f), FLOAT16(-0.1f), FLOAT16( 0.3f),
FLOAT16( 0.3f), FLOAT16( 1.0f), FLOAT16( 2.3f), FLOAT16(-4.1f)
ov::float16(-0.2f), ov::float16( 1.3f), ov::float16( 0.5f), ov::float16(-0.3f),
ov::float16( 2.3f), ov::float16( 1.3f), ov::float16(-0.4f), ov::float16(-0.7f),
ov::float16( 3.3f), ov::float16(-4.1f), ov::float16( 2.1f), ov::float16( 0.8f),
ov::float16( 3.5f), ov::float16(-5.7f), ov::float16(-0.1f), ov::float16( 0.3f),
ov::float16( 0.3f), ov::float16( 1.0f), ov::float16( 2.3f), ov::float16(-4.1f)
});
set_values<int32_t>(indices, {
0, 2,
@ -173,9 +173,9 @@ TEST(embedding_bag_fp16_gpu, packed_sum_dim2) {
3, 4
});
set_values(per_sample_weights, {
FLOAT16(0.5f), FLOAT16(0.5f),
FLOAT16(0.5f), FLOAT16(0.5f),
FLOAT16(0.5f), FLOAT16(0.5f)
ov::float16(0.5f), ov::float16(0.5f),
ov::float16(0.5f), ov::float16(0.5f),
ov::float16(0.5f), ov::float16(0.5f)
});
auto type = embedding_bag::packed_sum;
@ -279,16 +279,16 @@ TEST(embedding_bag_fp16_gpu, packed_sum_dim3) {
* ]
*/
set_values(emb_table, {
FLOAT16(-0.2f), FLOAT16( 1.3f), FLOAT16( 0.5f), FLOAT16(-0.3f), FLOAT16( 0.4f), FLOAT16(-0.4f),
FLOAT16(-0.1f), FLOAT16( 1.0f), FLOAT16( 2.1f), FLOAT16( 0.7f), FLOAT16(-0.2f), FLOAT16(-0.7f),
FLOAT16( 1.9f), FLOAT16(-2.4f), FLOAT16( 3.4f), FLOAT16(-0.7f), FLOAT16(-0.4f), FLOAT16( 0.5f),
FLOAT16( 2.3f), FLOAT16( 1.3f), FLOAT16(-0.4f), FLOAT16(-0.7f), FLOAT16( 1.8f), FLOAT16(-0.9f),
FLOAT16( 1.5f), FLOAT16(-2.4f), FLOAT16( 4.2f), FLOAT16( 3.2f), FLOAT16(-0.6f), FLOAT16( 0.9f),
FLOAT16( 3.3f), FLOAT16(-4.1f), FLOAT16( 2.1f), FLOAT16( 0.8f), FLOAT16( 5.2f), FLOAT16(-2.5f),
FLOAT16( 0.8f), FLOAT16(-1.9f), FLOAT16( 0.7f), FLOAT16( 3.4f), FLOAT16(-3.3f), FLOAT16( 0.1f),
FLOAT16( 3.5f), FLOAT16(-5.7f), FLOAT16(-0.1f), FLOAT16( 0.3f), FLOAT16( 0.4f), FLOAT16( 3.3f),
FLOAT16( 6.1f), FLOAT16( 8.3f), FLOAT16( 0.4f), FLOAT16(-4.4f), FLOAT16(-5.2f), FLOAT16( 0.9f),
FLOAT16( 0.3f), FLOAT16( 1.0f), FLOAT16( 2.3f), FLOAT16(-4.1f), FLOAT16( 2.0f), FLOAT16(-5.7f)
ov::float16(-0.2f), ov::float16( 1.3f), ov::float16( 0.5f), ov::float16(-0.3f), ov::float16( 0.4f), ov::float16(-0.4f),
ov::float16(-0.1f), ov::float16( 1.0f), ov::float16( 2.1f), ov::float16( 0.7f), ov::float16(-0.2f), ov::float16(-0.7f),
ov::float16( 1.9f), ov::float16(-2.4f), ov::float16( 3.4f), ov::float16(-0.7f), ov::float16(-0.4f), ov::float16( 0.5f),
ov::float16( 2.3f), ov::float16( 1.3f), ov::float16(-0.4f), ov::float16(-0.7f), ov::float16( 1.8f), ov::float16(-0.9f),
ov::float16( 1.5f), ov::float16(-2.4f), ov::float16( 4.2f), ov::float16( 3.2f), ov::float16(-0.6f), ov::float16( 0.9f),
ov::float16( 3.3f), ov::float16(-4.1f), ov::float16( 2.1f), ov::float16( 0.8f), ov::float16( 5.2f), ov::float16(-2.5f),
ov::float16( 0.8f), ov::float16(-1.9f), ov::float16( 0.7f), ov::float16( 3.4f), ov::float16(-3.3f), ov::float16( 0.1f),
ov::float16( 3.5f), ov::float16(-5.7f), ov::float16(-0.1f), ov::float16( 0.3f), ov::float16( 0.4f), ov::float16( 3.3f),
ov::float16( 6.1f), ov::float16( 8.3f), ov::float16( 0.4f), ov::float16(-4.4f), ov::float16(-5.2f), ov::float16( 0.9f),
ov::float16( 0.3f), ov::float16( 1.0f), ov::float16( 2.3f), ov::float16(-4.1f), ov::float16( 2.0f), ov::float16(-5.7f)
});
set_values<int32_t>(indices, {
0, 2,
@ -296,9 +296,9 @@ TEST(embedding_bag_fp16_gpu, packed_sum_dim3) {
3, 4
});
set_values(per_sample_weights, {
FLOAT16(0.5f), FLOAT16(0.5f),
FLOAT16(0.5f), FLOAT16(0.5f),
FLOAT16(0.5f), FLOAT16(0.5f)
ov::float16(0.5f), ov::float16(0.5f),
ov::float16(0.5f), ov::float16(0.5f),
ov::float16(0.5f), ov::float16(0.5f)
});
auto type = embedding_bag::packed_sum;
@ -379,11 +379,11 @@ TEST(embedding_bag_fp16_gpu, offsets_sum_basic) {
tensor output_shape = {3, 2, 1, 1};
set_values(emb_table, {
FLOAT16(-0.2f), FLOAT16(-0.6f),
FLOAT16(-0.1f), FLOAT16(-0.4f),
FLOAT16(-1.9f), FLOAT16(-1.8f),
FLOAT16(-1.0f), FLOAT16(1.5f),
FLOAT16(0.8f), FLOAT16(-0.7f)
ov::float16(-0.2f), ov::float16(-0.6f),
ov::float16(-0.1f), ov::float16(-0.4f),
ov::float16(-1.9f), ov::float16(-1.8f),
ov::float16(-1.0f), ov::float16(1.5f),
ov::float16(0.8f), ov::float16(-0.7f)
});
set_values<int32_t>(indices, {
0, 2, 3, 4
@ -392,7 +392,7 @@ TEST(embedding_bag_fp16_gpu, offsets_sum_basic) {
0, 2, 2
});
set_values(per_sample_weights, {
FLOAT16(0.5f), FLOAT16(0.5f), FLOAT16(0.5f), FLOAT16(0.5f)
ov::float16(0.5f), ov::float16(0.5f), ov::float16(0.5f), ov::float16(0.5f)
});
auto type = embedding_bag::offsets_sum;
@ -443,11 +443,11 @@ TEST(embedding_bag_fp16_gpu, offsets_sum_basic_first_empty) {
tensor output_shape = {3, 2, 1, 1};
set_values(emb_table, {
FLOAT16(-0.2f), FLOAT16(-0.6f),
FLOAT16(-0.1f), FLOAT16(-0.4f),
FLOAT16(-1.9f), FLOAT16(-1.8f),
FLOAT16(-1.0f), FLOAT16(1.5f),
FLOAT16(0.8f), FLOAT16(-0.7f)
ov::float16(-0.2f), ov::float16(-0.6f),
ov::float16(-0.1f), ov::float16(-0.4f),
ov::float16(-1.9f), ov::float16(-1.8f),
ov::float16(-1.0f), ov::float16(1.5f),
ov::float16(0.8f), ov::float16(-0.7f)
});
set_values<int32_t>(indices, {
0, 2, 3, 4
@ -456,7 +456,7 @@ TEST(embedding_bag_fp16_gpu, offsets_sum_basic_first_empty) {
0, 0, 2
});
set_values(per_sample_weights, {
FLOAT16(0.5f), FLOAT16(0.5f), FLOAT16(0.5f), FLOAT16(0.5f)
ov::float16(0.5f), ov::float16(0.5f), ov::float16(0.5f), ov::float16(0.5f)
});
auto type = embedding_bag::offsets_sum;
@ -508,11 +508,11 @@ TEST(embedding_bag_fp16_gpu, offsets_sum_basic_last_empty) {
tensor output_shape = {3, 2, 1, 1};
set_values(emb_table, {
FLOAT16(-0.2f), FLOAT16(-0.6f),
FLOAT16(-0.1f), FLOAT16(-0.4f),
FLOAT16(-1.9f), FLOAT16(-1.8f),
FLOAT16(-1.0f), FLOAT16(1.5f),
FLOAT16(0.8f), FLOAT16(-0.7f)
ov::float16(-0.2f), ov::float16(-0.6f),
ov::float16(-0.1f), ov::float16(-0.4f),
ov::float16(-1.9f), ov::float16(-1.8f),
ov::float16(-1.0f), ov::float16(1.5f),
ov::float16(0.8f), ov::float16(-0.7f)
});
set_values<int32_t>(indices, {
0, 2, 3, 4
@ -521,7 +521,7 @@ TEST(embedding_bag_fp16_gpu, offsets_sum_basic_last_empty) {
0, 2, 4
});
set_values(per_sample_weights, {
FLOAT16(0.5f), FLOAT16(0.5f), FLOAT16(0.5f), FLOAT16(0.5f)
ov::float16(0.5f), ov::float16(0.5f), ov::float16(0.5f), ov::float16(0.5f)
});
auto type = embedding_bag::offsets_sum;
@ -570,11 +570,11 @@ TEST(embedding_bag_fp16_gpu, offsets_sum_without_weights_and_def_index) {
tensor output_shape = {3, 2, 1, 1};
set_values(emb_table, {
FLOAT16(-0.2f), FLOAT16(-0.6f),
FLOAT16(-0.1f), FLOAT16(-0.4f),
FLOAT16(-1.9f), FLOAT16(-1.8f),
FLOAT16(-1.0f), FLOAT16(1.5f),
FLOAT16(0.8f), FLOAT16(-0.7f)
ov::float16(-0.2f), ov::float16(-0.6f),
ov::float16(-0.1f), ov::float16(-0.4f),
ov::float16(-1.9f), ov::float16(-1.8f),
ov::float16(-1.0f), ov::float16(1.5f),
ov::float16(0.8f), ov::float16(-0.7f)
});
set_values<int32_t>(indices, {
0, 2, 3, 4
@ -675,16 +675,16 @@ TEST(embedding_bag_fp16_gpu, offsets_sum_dim3) {
* ]
*/
set_values(emb_table, {
FLOAT16(-0.2f), FLOAT16( 1.3f), FLOAT16( 0.5f), FLOAT16(-0.3f), FLOAT16( 0.4f), FLOAT16(-0.4f),
FLOAT16(-0.1f), FLOAT16( 1.0f), FLOAT16( 2.1f), FLOAT16( 0.7f), FLOAT16(-0.2f), FLOAT16(-0.7f),
FLOAT16( 1.9f), FLOAT16(-2.4f), FLOAT16( 3.4f), FLOAT16(-0.7f), FLOAT16(-0.4f), FLOAT16( 0.5f),
FLOAT16( 2.3f), FLOAT16( 1.3f), FLOAT16(-0.4f), FLOAT16(-0.7f), FLOAT16( 1.8f), FLOAT16(-0.9f),
FLOAT16( 1.5f), FLOAT16(-2.4f), FLOAT16( 4.2f), FLOAT16( 3.2f), FLOAT16(-0.6f), FLOAT16( 0.9f),
FLOAT16( 3.3f), FLOAT16(-4.1f), FLOAT16( 2.1f), FLOAT16( 0.8f), FLOAT16( 5.2f), FLOAT16(-2.5f),
FLOAT16( 0.8f), FLOAT16(-1.9f), FLOAT16( 0.7f), FLOAT16( 3.4f), FLOAT16(-3.3f), FLOAT16( 0.1f),
FLOAT16( 3.5f), FLOAT16(-5.7f), FLOAT16(-0.1f), FLOAT16( 0.3f), FLOAT16( 0.4f), FLOAT16( 3.3f),
FLOAT16( 6.1f), FLOAT16( 8.3f), FLOAT16( 0.4f), FLOAT16(-4.4f), FLOAT16(-5.2f), FLOAT16( 0.9f),
FLOAT16( 0.3f), FLOAT16( 1.0f), FLOAT16( 2.3f), FLOAT16(-4.1f), FLOAT16( 2.0f), FLOAT16(-5.7f)
ov::float16(-0.2f), ov::float16( 1.3f), ov::float16( 0.5f), ov::float16(-0.3f), ov::float16( 0.4f), ov::float16(-0.4f),
ov::float16(-0.1f), ov::float16( 1.0f), ov::float16( 2.1f), ov::float16( 0.7f), ov::float16(-0.2f), ov::float16(-0.7f),
ov::float16( 1.9f), ov::float16(-2.4f), ov::float16( 3.4f), ov::float16(-0.7f), ov::float16(-0.4f), ov::float16( 0.5f),
ov::float16( 2.3f), ov::float16( 1.3f), ov::float16(-0.4f), ov::float16(-0.7f), ov::float16( 1.8f), ov::float16(-0.9f),
ov::float16( 1.5f), ov::float16(-2.4f), ov::float16( 4.2f), ov::float16( 3.2f), ov::float16(-0.6f), ov::float16( 0.9f),
ov::float16( 3.3f), ov::float16(-4.1f), ov::float16( 2.1f), ov::float16( 0.8f), ov::float16( 5.2f), ov::float16(-2.5f),
ov::float16( 0.8f), ov::float16(-1.9f), ov::float16( 0.7f), ov::float16( 3.4f), ov::float16(-3.3f), ov::float16( 0.1f),
ov::float16( 3.5f), ov::float16(-5.7f), ov::float16(-0.1f), ov::float16( 0.3f), ov::float16( 0.4f), ov::float16( 3.3f),
ov::float16( 6.1f), ov::float16( 8.3f), ov::float16( 0.4f), ov::float16(-4.4f), ov::float16(-5.2f), ov::float16( 0.9f),
ov::float16( 0.3f), ov::float16( 1.0f), ov::float16( 2.3f), ov::float16(-4.1f), ov::float16( 2.0f), ov::float16(-5.7f)
});
set_values<int32_t>(indices, {
0, 2, 3, 4
@ -693,8 +693,8 @@ TEST(embedding_bag_fp16_gpu, offsets_sum_dim3) {
0, 2, 2
});
set_values(per_sample_weights, {
FLOAT16(0.5f), FLOAT16(0.5f),
FLOAT16(0.5f), FLOAT16(0.5f)
ov::float16(0.5f), ov::float16(0.5f),
ov::float16(0.5f), ov::float16(0.5f)
});
auto type = embedding_bag::offsets_sum;
@ -777,11 +777,11 @@ TEST(embedding_bag_fp16_gpu, segments_sum_basic) {
tensor output_shape = {3, 2, 1, 1};
set_values(emb_table, {
FLOAT16(-0.2f), FLOAT16(-0.6f),
FLOAT16(-0.1f), FLOAT16(-0.4f),
FLOAT16(-1.9f), FLOAT16(-1.8f),
FLOAT16(-1.0f), FLOAT16(1.5f),
FLOAT16(0.8f), FLOAT16(-0.7f)
ov::float16(-0.2f), ov::float16(-0.6f),
ov::float16(-0.1f), ov::float16(-0.4f),
ov::float16(-1.9f), ov::float16(-1.8f),
ov::float16(-1.0f), ov::float16(1.5f),
ov::float16(0.8f), ov::float16(-0.7f)
});
set_values<int32_t>(indices, {
0, 2, 3, 4
@ -790,7 +790,7 @@ TEST(embedding_bag_fp16_gpu, segments_sum_basic) {
0, 0, 2, 2
});
set_values(per_sample_weights, {
FLOAT16(0.5f), FLOAT16(0.5f), FLOAT16(0.5f), FLOAT16(0.5f)
ov::float16(0.5f), ov::float16(0.5f), ov::float16(0.5f), ov::float16(0.5f)
});
auto type = embedding_bag::segments_sum;
@ -842,11 +842,11 @@ TEST(embedding_bag_fp16_gpu, segments_sum_basic_first_empty) {
tensor output_shape = {3, 2, 1, 1};
set_values(emb_table, {
FLOAT16(-0.2f), FLOAT16(-0.6f),
FLOAT16(-0.1f), FLOAT16(-0.4f),
FLOAT16(-1.9f), FLOAT16(-1.8f),
FLOAT16(-1.0f), FLOAT16(1.5f),
FLOAT16(0.8f), FLOAT16(-0.7f)
ov::float16(-0.2f), ov::float16(-0.6f),
ov::float16(-0.1f), ov::float16(-0.4f),
ov::float16(-1.9f), ov::float16(-1.8f),
ov::float16(-1.0f), ov::float16(1.5f),
ov::float16(0.8f), ov::float16(-0.7f)
});
set_values<int32_t>(indices, {
0, 2, 3, 4
@ -855,7 +855,7 @@ TEST(embedding_bag_fp16_gpu, segments_sum_basic_first_empty) {
1, 1, 2, 2
});
set_values(per_sample_weights, {
FLOAT16(0.5f), FLOAT16(0.5f), FLOAT16(0.5f), FLOAT16(0.5f)
ov::float16(0.5f), ov::float16(0.5f), ov::float16(0.5f), ov::float16(0.5f)
});
auto type = embedding_bag::segments_sum;
@ -907,11 +907,11 @@ TEST(embedding_bag_fp16_gpu, segments_sum_basic_last_empty) {
tensor output_shape = {3, 2, 1, 1};
set_values(emb_table, {
FLOAT16(-0.2f), FLOAT16(-0.6f),
FLOAT16(-0.1f), FLOAT16(-0.4f),
FLOAT16(-1.9f), FLOAT16(-1.8f),
FLOAT16(-1.0f), FLOAT16(1.5f),
FLOAT16(0.8f), FLOAT16(-0.7f)
ov::float16(-0.2f), ov::float16(-0.6f),
ov::float16(-0.1f), ov::float16(-0.4f),
ov::float16(-1.9f), ov::float16(-1.8f),
ov::float16(-1.0f), ov::float16(1.5f),
ov::float16(0.8f), ov::float16(-0.7f)
});
set_values<int32_t>(indices, {
0, 2, 3, 4
@ -920,7 +920,7 @@ TEST(embedding_bag_fp16_gpu, segments_sum_basic_last_empty) {
0, 0, 1, 1
});
set_values(per_sample_weights, {
FLOAT16(0.5f), FLOAT16(0.5f), FLOAT16(0.5f), FLOAT16(0.5f)
ov::float16(0.5f), ov::float16(0.5f), ov::float16(0.5f), ov::float16(0.5f)
});
auto type = embedding_bag::segments_sum;
@ -969,11 +969,11 @@ TEST(embedding_bag_fp16_gpu, segments_sum_without_weights_and_def_index) {
tensor output_shape = {3, 2, 1, 1};
set_values(emb_table, {
FLOAT16(-0.2f), FLOAT16(-0.6f),
FLOAT16(-0.1f), FLOAT16(-0.4f),
FLOAT16(-1.9f), FLOAT16(-1.8f),
FLOAT16(-1.0f), FLOAT16(1.5f),
FLOAT16(0.8f), FLOAT16(-0.7f)
ov::float16(-0.2f), ov::float16(-0.6f),
ov::float16(-0.1f), ov::float16(-0.4f),
ov::float16(-1.9f), ov::float16(-1.8f),
ov::float16(-1.0f), ov::float16(1.5f),
ov::float16(0.8f), ov::float16(-0.7f)
});
set_values<int32_t>(indices, {
0, 2, 3, 4
@ -1074,16 +1074,16 @@ TEST(embedding_bag_fp16_gpu, segments_sum_dim3) {
* ]
*/
set_values(emb_table, {
FLOAT16(-0.2f), FLOAT16( 1.3f), FLOAT16( 0.5f), FLOAT16(-0.3f), FLOAT16( 0.4f), FLOAT16(-0.4f),
FLOAT16(-0.1f), FLOAT16( 1.0f), FLOAT16( 2.1f), FLOAT16( 0.7f), FLOAT16(-0.2f), FLOAT16(-0.7f),
FLOAT16( 1.9f), FLOAT16(-2.4f), FLOAT16( 3.4f), FLOAT16(-0.7f), FLOAT16(-0.4f), FLOAT16( 0.5f),
FLOAT16( 2.3f), FLOAT16( 1.3f), FLOAT16(-0.4f), FLOAT16(-0.7f), FLOAT16( 1.8f), FLOAT16(-0.9f),
FLOAT16( 1.5f), FLOAT16(-2.4f), FLOAT16( 4.2f), FLOAT16( 3.2f), FLOAT16(-0.6f), FLOAT16( 0.9f),
FLOAT16( 3.3f), FLOAT16(-4.1f), FLOAT16( 2.1f), FLOAT16( 0.8f), FLOAT16( 5.2f), FLOAT16(-2.5f),
FLOAT16( 0.8f), FLOAT16(-1.9f), FLOAT16( 0.7f), FLOAT16( 3.4f), FLOAT16(-3.3f), FLOAT16( 0.1f),
FLOAT16( 3.5f), FLOAT16(-5.7f), FLOAT16(-0.1f), FLOAT16( 0.3f), FLOAT16( 0.4f), FLOAT16( 3.3f),
FLOAT16( 6.1f), FLOAT16( 8.3f), FLOAT16( 0.4f), FLOAT16(-4.4f), FLOAT16(-5.2f), FLOAT16( 0.9f),
FLOAT16( 0.3f), FLOAT16( 1.0f), FLOAT16( 2.3f), FLOAT16(-4.1f), FLOAT16( 2.0f), FLOAT16(-5.7f)
ov::float16(-0.2f), ov::float16( 1.3f), ov::float16( 0.5f), ov::float16(-0.3f), ov::float16( 0.4f), ov::float16(-0.4f),
ov::float16(-0.1f), ov::float16( 1.0f), ov::float16( 2.1f), ov::float16( 0.7f), ov::float16(-0.2f), ov::float16(-0.7f),
ov::float16( 1.9f), ov::float16(-2.4f), ov::float16( 3.4f), ov::float16(-0.7f), ov::float16(-0.4f), ov::float16( 0.5f),
ov::float16( 2.3f), ov::float16( 1.3f), ov::float16(-0.4f), ov::float16(-0.7f), ov::float16( 1.8f), ov::float16(-0.9f),
ov::float16( 1.5f), ov::float16(-2.4f), ov::float16( 4.2f), ov::float16( 3.2f), ov::float16(-0.6f), ov::float16( 0.9f),
ov::float16( 3.3f), ov::float16(-4.1f), ov::float16( 2.1f), ov::float16( 0.8f), ov::float16( 5.2f), ov::float16(-2.5f),
ov::float16( 0.8f), ov::float16(-1.9f), ov::float16( 0.7f), ov::float16( 3.4f), ov::float16(-3.3f), ov::float16( 0.1f),
ov::float16( 3.5f), ov::float16(-5.7f), ov::float16(-0.1f), ov::float16( 0.3f), ov::float16( 0.4f), ov::float16( 3.3f),
ov::float16( 6.1f), ov::float16( 8.3f), ov::float16( 0.4f), ov::float16(-4.4f), ov::float16(-5.2f), ov::float16( 0.9f),
ov::float16( 0.3f), ov::float16( 1.0f), ov::float16( 2.3f), ov::float16(-4.1f), ov::float16( 2.0f), ov::float16(-5.7f)
});
set_values<int32_t>(indices, {
0, 2, 3, 4
@ -1092,8 +1092,8 @@ TEST(embedding_bag_fp16_gpu, segments_sum_dim3) {
0, 0, 2, 2
});
set_values(per_sample_weights, {
FLOAT16(0.5f), FLOAT16(0.5f),
FLOAT16(0.5f), FLOAT16(0.5f)
ov::float16(0.5f), ov::float16(0.5f),
ov::float16(0.5f), ov::float16(0.5f)
});
auto type = embedding_bag::segments_sum;

10
src/plugins/intel_gpu/tests/unit/test_cases/experimental_detectron_detection_output_gpu_test.cpp
View File

@ -28,7 +28,7 @@ float getError<float>() {
}
template <>
float getError<half_t>() {
float getError<ov::float16>() {
return 0.2;
}
@ -70,7 +70,7 @@ public:
format::type fmt;
bool is_caching_test;
std::tie(param, fmt, is_caching_test) = this->GetParam();
auto data_type = type_to_data_type<T>::value;
auto data_type = ov::element::from<T>();
auto& engine = get_test_engine();
@ -197,7 +197,7 @@ public:
};
using experimental_detectron_detection_output_test_f32 = experimental_detectron_detection_output_test<float>;
using experimental_detectron_detection_output_test_f16 = experimental_detectron_detection_output_test<half_t>;
using experimental_detectron_detection_output_test_f16 = experimental_detectron_detection_output_test<ov::float16>;
TEST_P(experimental_detectron_detection_output_test_f32, basic) {
ASSERT_NO_FATAL_FAILURE(test());
@ -442,7 +442,7 @@ INSTANTIATE_TEST_SUITE_P(experimental_detectron_detection_output_gpu_test,
INSTANTIATE_TEST_SUITE_P(experimental_detectron_detection_output_gpu_test,
experimental_detectron_detection_output_test_f16,
testing::Combine(
::testing::ValuesIn(getExperimentalDetectronDetectionOutputParams<half_t>()),
::testing::ValuesIn(getExperimentalDetectronDetectionOutputParams<ov::float16>()),
::testing::ValuesIn(layouts),
::testing::Values(false)
));
@ -450,7 +450,7 @@ INSTANTIATE_TEST_SUITE_P(experimental_detectron_detection_output_gpu_test,
INSTANTIATE_TEST_SUITE_P(export_import,
experimental_detectron_detection_output_test_f16,
testing::Combine(
::testing::Values(getExperimentalDetectronDetectionOutputParams<half_t>()[0]),
::testing::Values(getExperimentalDetectronDetectionOutputParams<ov::float16>()[0]),
::testing::Values(layouts[0]),
::testing::Values(true)
));

12
src/plugins/intel_gpu/tests/unit/test_cases/experimental_detectron_generate_proposals_single_image_gpu_test.cpp
View File

@ -93,8 +93,8 @@ float getError<float>() {
}
template<>
float getError<half_t>() {
return 0.2;
float getError<ov::float16>() {
return 0.25;
}
template <typename T>
@ -179,7 +179,7 @@ public:
format::type data_layout;
bool is_caching_test;
std::tie(param, data_layout, is_caching_test) = this->GetParam();
const auto data_type = type_to_data_type<T>::value;
const auto data_type = ov::element::from<T>();
auto &engine = get_test_engine();
@ -289,7 +289,7 @@ using experimental_detectron_generate_proposals_single_image_test_f32 = experime
TEST_P(experimental_detectron_generate_proposals_single_image_test_f32, basic) {
ASSERT_NO_FATAL_FAILURE(test());
}
using experimental_detectron_generate_proposals_single_image_test_f16 = experimental_detectron_generate_proposals_single_image_test<half_t>;
using experimental_detectron_generate_proposals_single_image_test_f16 = experimental_detectron_generate_proposals_single_image_test<ov::float16>;
TEST_P(experimental_detectron_generate_proposals_single_image_test_f16, basic) {
ASSERT_NO_FATAL_FAILURE(test());
}
@ -309,7 +309,7 @@ INSTANTIATE_TEST_SUITE_P(
experimental_detectron_generate_proposals_single_image_gpu_test,
experimental_detectron_generate_proposals_single_image_test_f16,
::testing::Combine(
::testing::ValuesIn(getExperimentalDetectronGenerateProposalsSingleImageParams<half_t>()),
::testing::ValuesIn(getExperimentalDetectronGenerateProposalsSingleImageParams<ov::float16>()),
::testing::Values(format::bfyx),
::testing::Values(false)
),
@ -320,7 +320,7 @@ INSTANTIATE_TEST_SUITE_P(
export_import,
experimental_detectron_generate_proposals_single_image_test_f16,
::testing::Combine(
::testing::Values(getExperimentalDetectronGenerateProposalsSingleImageParams<half_t>()[0]),
::testing::Values(getExperimentalDetectronGenerateProposalsSingleImageParams<ov::float16>()[0]),
::testing::Values(format::bfyx),
::testing::Values(true)
),

8
src/plugins/intel_gpu/tests/unit/test_cases/experimental_detectron_prior_grid_generator_gpu_test.cpp
View File

@ -34,7 +34,7 @@ struct experimental_detectron_prior_grid_generator_test
: public ::testing::TestWithParam<ExperimentalDetectronPriorGridGeneratorParams<T>> {
public:
void test() {
auto data_type = type_to_data_type<T>::value;
auto data_type = ov::element::from<T>();
ExperimentalDetectronPriorGridGeneratorParams<T> params =
testing::TestWithParam<ExperimentalDetectronPriorGridGeneratorParams<T>>::GetParam();
auto& engine = get_test_engine();
@ -213,7 +213,7 @@ struct PrintToStringParamName {
};
using experimental_detectron_prior_grid_generator_test_f32 = experimental_detectron_prior_grid_generator_test<float>;
using experimental_detectron_prior_grid_generator_test_f16 = experimental_detectron_prior_grid_generator_test<half_t>;
using experimental_detectron_prior_grid_generator_test_f16 = experimental_detectron_prior_grid_generator_test<ov::float16>;
TEST_P(experimental_detectron_prior_grid_generator_test_f32, experimental_detectron_prior_grid_generator_test_f32) {
ASSERT_NO_FATAL_FAILURE(test());
@ -230,10 +230,10 @@ INSTANTIATE_TEST_SUITE_P(smoke_experimental_detectron_prior_grid_generator_test_
INSTANTIATE_TEST_SUITE_P(smoke_experimental_detectron_prior_grid_generator_test_f16,
experimental_detectron_prior_grid_generator_test_f16,
::testing::ValuesIn(generateExperimentalPGGParams<half_t>()),
::testing::ValuesIn(generateExperimentalPGGParams<ov::float16>()),
PrintToStringParamName());
INSTANTIATE_TEST_SUITE_P(export_import,
experimental_detectron_prior_grid_generator_test_f16,
::testing::Values(generateExperimentalPGGParams<half_t>(true)[0]),
::testing::Values(generateExperimentalPGGParams<ov::float16>(true)[0]),
PrintToStringParamName());

17
src/plugins/intel_gpu/tests/unit/test_cases/experimental_detectron_topk_rois_gpu_test.cpp
View File

@ -17,14 +17,13 @@ template <format::type layoutFormat, typename DataType>
struct experimental_detectron_topk_rois_input_types {
static const auto format = layoutFormat;
using type = DataType;
static const data_types data_type = type_to_data_type<DataType>::value;
};
template <typename EdTopkRoisInput>
struct experimental_detectron_topk_rois_gpu_test : public testing::Test {
static const auto format = EdTopkRoisInput::format;
static const auto data_type = EdTopkRoisInput::data_type;
using input_type = typename EdTopkRoisInput::type;
const ov::element::Type data_type = ov::element::from<input_type>();
std::vector<input_type> getTypedVector(const std::vector<float>& input) {
return std::vector<input_type>(input.begin(), input.end());
@ -45,12 +44,12 @@ using format_types = testing::Types<experimental_detectron_topk_rois_input_types
experimental_detectron_topk_rois_input_types<format::bs_fs_yx_bsv16_fsv16, float>,
experimental_detectron_topk_rois_input_types<format::bs_fs_yx_bsv32_fsv16, float>,
experimental_detectron_topk_rois_input_types<format::bs_fs_yx_bsv32_fsv32, float>,
experimental_detectron_topk_rois_input_types<format::bfyx, half_t>,
experimental_detectron_topk_rois_input_types<format::b_fs_yx_fsv16, half_t>,
experimental_detectron_topk_rois_input_types<format::b_fs_yx_fsv32, half_t>,
experimental_detectron_topk_rois_input_types<format::bs_fs_yx_bsv16_fsv16, half_t>,
experimental_detectron_topk_rois_input_types<format::bs_fs_yx_bsv32_fsv16, half_t>,
experimental_detectron_topk_rois_input_types<format::bs_fs_yx_bsv32_fsv32, half_t>>;
experimental_detectron_topk_rois_input_types<format::bfyx, ov::float16>,
experimental_detectron_topk_rois_input_types<format::b_fs_yx_fsv16, ov::float16>,
experimental_detectron_topk_rois_input_types<format::b_fs_yx_fsv32, ov::float16>,
experimental_detectron_topk_rois_input_types<format::bs_fs_yx_bsv16_fsv16, ov::float16>,
experimental_detectron_topk_rois_input_types<format::bs_fs_yx_bsv32_fsv16, ov::float16>,
experimental_detectron_topk_rois_input_types<format::bs_fs_yx_bsv32_fsv32, ov::float16>>;
TYPED_TEST_SUITE(experimental_detectron_topk_rois_gpu_test, format_types);
@ -133,7 +132,7 @@ TYPED_TEST(experimental_detectron_topk_rois_gpu_test, check_set_indices_layer_mo
TEST(experimental_detectron_topk_rois_gpu_test, export_import) {
const auto test_format = format::bs_fs_yx_bsv32_fsv16;
const data_types test_data_type = type_to_data_type<float>::value;
const data_types test_data_type = ov::element::from<float>();
auto& engine = get_test_engine();
// topk is more than model size

22
src/plugins/intel_gpu/tests/unit/test_cases/eye.cpp
View File

@ -39,11 +39,11 @@ public:
bool is_caching_test;
std::tie(fmt, cols, rows, diag, batch_shape, output_shape, expected_values, is_caching_test) = this->GetParam();
auto num_rows = engine_.allocate_memory({type_to_data_type<InputType>::value, fmt, tensor{1}});
auto num_rows = engine_.allocate_memory({ov::element::from<InputType>(), fmt, tensor{1}});
set_values<InputType>(num_rows, {rows});
auto num_coloms = engine_.allocate_memory({type_to_data_type<InputType>::value, fmt, tensor{1}});
auto num_coloms = engine_.allocate_memory({ov::element::from<InputType>(), fmt, tensor{1}});
set_values<InputType>(num_coloms, {cols});
auto diagonal_index = engine_.allocate_memory({type_to_data_type<InputType>::value, fmt, tensor{1}});
auto diagonal_index = engine_.allocate_memory({ov::element::from<InputType>(), fmt, tensor{1}});
set_values<InputType>(diagonal_index, {diag});
topology tp;
@ -54,7 +54,7 @@ public:
auto batch_rank = batch_shape.size() == 3 ? 3 : 2;
auto oupput_fmt = batch_rank == 3 ? format::bfzyx : format::bfyx;
if (!batch_shape.empty()) {
auto batch = engine_.allocate_memory({type_to_data_type<InputType>::value, fmt, tensor{batch_rank}});
auto batch = engine_.allocate_memory({ov::element::from<InputType>(), fmt, tensor{batch_rank}});
set_values<InputType>(batch, batch_shape);
tp.add(data("batch", batch));
}
@ -66,23 +66,23 @@ public:
: std::vector<input_info>{ input_info("num_rows"), input_info("num_columns"), input_info("diagonal_index"), input_info("batch") };
ouput_op_name = "eye";
auto eye_primitive =
eye("eye", inputs, tensor{output_shape}, diag, type_to_data_type<OutputType>::value);
eye("eye", inputs, tensor{output_shape}, diag, ov::element::from<OutputType>());
tp.add(std::move(eye_primitive));
} else {
tp.add(reorder("r_num_rows", input_info("num_rows"), fmt, type_to_data_type<InputType>::value));
tp.add(reorder("r_num_columns", input_info("num_columns"), fmt, type_to_data_type<InputType>::value));
tp.add(reorder("r_diagonal_index", input_info("diagonal_index"), fmt, type_to_data_type<InputType>::value));
tp.add(reorder("r_num_rows", input_info("num_rows"), fmt, ov::element::from<InputType>()));
tp.add(reorder("r_num_columns", input_info("num_columns"), fmt, ov::element::from<InputType>()));
tp.add(reorder("r_diagonal_index", input_info("diagonal_index"), fmt, ov::element::from<InputType>()));
if (!batch_shape.empty()) {
tp.add(reorder("r_batch", input_info("batch"), fmt, type_to_data_type<InputType>::value));
tp.add(reorder("r_batch", input_info("batch"), fmt, ov::element::from<InputType>()));
}
auto inputs = batch_shape.empty()
? std::vector<input_info>{ input_info("r_num_rows"), input_info("r_num_columns"), input_info("r_diagonal_index") }
: std::vector<input_info>{ input_info("r_num_rows"), input_info("r_num_columns"), input_info("r_diagonal_index"), input_info("r_batch") };
auto eye_primitive =
eye("eye", inputs, tensor{output_shape}, diag, type_to_data_type<OutputType>::value);
eye("eye", inputs, tensor{output_shape}, diag, ov::element::from<OutputType>());
tp.add(std::move(eye_primitive));
ouput_op_name = "output";
tp.add(reorder("output", input_info("eye"), oupput_fmt, type_to_data_type<OutputType>::value));
tp.add(reorder("output", input_info("eye"), oupput_fmt, ov::element::from<OutputType>()));
}
cldnn::network::ptr network = get_network(engine_, tp, get_test_default_config(engine_), get_test_stream_ptr(), is_caching_test);

79
src/plugins/intel_gpu/tests/unit/test_cases/fully_connected_gpu_test.cpp
View File

@ -6,7 +6,6 @@
#include "intel_gpu/runtime/layout.hpp"
#include "openvino/core/partial_shape.hpp"
#include "test_utils.h"
#include "float16.h"
#include "random_generator.hpp"
#include "network_test.h"
#include <intel_gpu/runtime/utils.hpp>
@ -76,9 +75,9 @@ void generic_fully_connected_test(cldnn::format test_input_fmt, cldnn::format te
auto& engine = get_test_engine();
tensor input_tensor(input_b, f, x, y);
tensor weights_tensor(output_f, f, x, y);
auto input = engine.allocate_memory({ type_to_data_type<T>::value, test_input_fmt, input_tensor });
auto weights = engine.allocate_memory({ type_to_data_type<T>::value, test_weights_fmt, weights_tensor });
auto bias = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx, { 1, 1, output_f, 1 } });
auto input = engine.allocate_memory({ ov::element::from<T>(), test_input_fmt, input_tensor });
auto weights = engine.allocate_memory({ ov::element::from<T>(), test_weights_fmt, weights_tensor });
auto bias = engine.allocate_memory({ ov::element::from<T>(), format::bfyx, { 1, 1, output_f, 1 } });
set_values(input, input_rnd_vec);
set_values(weights, weights_rnd_vec);
set_values(bias, bias_rnd_vec);
@ -165,7 +164,7 @@ TEST(DISABLED_fully_connected_gpu, generic_random_short) {
generic_fully_connected_test<float>(test_input_fmt, test_weights_fmt,
b, f, sizes.second, sizes.first, output_f, relu_activated);
if (!f16_supported) continue;
generic_fully_connected_test<FLOAT16>(test_input_fmt, test_weights_fmt,
generic_fully_connected_test<ov::float16>(test_input_fmt, test_weights_fmt,
b, f, sizes.second, sizes.first, output_f, relu_activated);
}
}
@ -780,18 +779,18 @@ TEST(fully_connected_gpu, compressed_scale_fp16) {
auto weights_mem = engine.allocate_memory({ {8, 4}, data_types::f16, format::bfyx });
auto scale_mem = engine.allocate_memory({ {1, 8}, data_types::f16, format::bfyx });
set_values<FLOAT16>(input_mem, { FLOAT16(-0.5f), FLOAT16(2.0f), FLOAT16(0.5f), FLOAT16(1.0f),
FLOAT16(0.5f), FLOAT16(-2.0f), FLOAT16(-0.5f), FLOAT16(-1.0f) });
set_values<FLOAT16>(weights_mem, {FLOAT16( 1.5f), FLOAT16( 1.0f), FLOAT16( 0.5f), FLOAT16(-1.0f),
FLOAT16( 0.0f), FLOAT16( 0.5f), FLOAT16( 0.5f), FLOAT16(-0.5f),
FLOAT16(-2.0f), FLOAT16(-0.5f), FLOAT16( 1.0f), FLOAT16( 1.5f),
FLOAT16(-2.0f), FLOAT16(-0.5f), FLOAT16( 1.0f), FLOAT16( 1.5f),
FLOAT16( 2.0f), FLOAT16( 0.5f), FLOAT16(-1.0f), FLOAT16(-1.5f),
FLOAT16( 2.0f), FLOAT16( 0.5f), FLOAT16(-1.0f), FLOAT16(-1.5f),
FLOAT16(-1.5f), FLOAT16(-1.0f), FLOAT16(-0.5f), FLOAT16( 1.0f),
FLOAT16( 0.0f), FLOAT16(-0.5f), FLOAT16(0.5f), FLOAT16( 0.5f) });
set_values<ov::float16>(input_mem, { ov::float16(-0.5f), ov::float16(2.0f), ov::float16(0.5f), ov::float16(1.0f),
ov::float16(0.5f), ov::float16(-2.0f), ov::float16(-0.5f), ov::float16(-1.0f) });
set_values<ov::float16>(weights_mem, {ov::float16( 1.5f), ov::float16( 1.0f), ov::float16( 0.5f), ov::float16(-1.0f),
ov::float16( 0.0f), ov::float16( 0.5f), ov::float16( 0.5f), ov::float16(-0.5f),
ov::float16(-2.0f), ov::float16(-0.5f), ov::float16( 1.0f), ov::float16( 1.5f),
ov::float16(-2.0f), ov::float16(-0.5f), ov::float16( 1.0f), ov::float16( 1.5f),
ov::float16( 2.0f), ov::float16( 0.5f), ov::float16(-1.0f), ov::float16(-1.5f),
ov::float16( 2.0f), ov::float16( 0.5f), ov::float16(-1.0f), ov::float16(-1.5f),
ov::float16(-1.5f), ov::float16(-1.0f), ov::float16(-0.5f), ov::float16( 1.0f),
ov::float16( 0.0f), ov::float16(-0.5f), ov::float16(0.5f), ov::float16( 0.5f) });
set_values<FLOAT16>(scale_mem, {FLOAT16(2.0f), FLOAT16(4.0f), FLOAT16(-2.0f), FLOAT16(-4.0f), FLOAT16(0.5f), FLOAT16(-0.5f), FLOAT16(2.0f), FLOAT16(2.0f)});
set_values<ov::float16>(scale_mem, {ov::float16(2.0f), ov::float16(4.0f), ov::float16(-2.0f), ov::float16(-4.0f), ov::float16(0.5f), ov::float16(-0.5f), ov::float16(2.0f), ov::float16(2.0f)});
topology topology(
input_layout("input", input_mem->get_layout()),
@ -812,14 +811,14 @@ TEST(fully_connected_gpu, compressed_scale_fp16) {
auto output_mem = outputs.begin()->second.get_memory();
cldnn::mem_lock<FLOAT16> output_ptr (output_mem, get_test_stream());
cldnn::mem_lock<ov::float16> output_ptr (output_mem, get_test_stream());
ov::PartialShape expected_shape{2, 8};
ASSERT_EQ(expected_shape, output_mem->get_layout().get_partial_shape());
std::vector<FLOAT16> expected_result = {
FLOAT16(1.0f), FLOAT16( 3.0f), FLOAT16(-4.0f), FLOAT16(-8.0f), FLOAT16(-1.0f), FLOAT16( 1.0f), FLOAT16(-1.0f), FLOAT16(-0.5f),
FLOAT16(-1.0f), FLOAT16(-3.0f), FLOAT16( 4.0f), FLOAT16( 8.0f), FLOAT16( 1.0f), FLOAT16(-1.0f), FLOAT16( 1.0f), FLOAT16( 0.5f)};
std::vector<ov::float16> expected_result = {
ov::float16(1.0f), ov::float16( 3.0f), ov::float16(-4.0f), ov::float16(-8.0f), ov::float16(-1.0f), ov::float16( 1.0f), ov::float16(-1.0f), ov::float16(-0.5f),
ov::float16(-1.0f), ov::float16(-3.0f), ov::float16( 4.0f), ov::float16( 8.0f), ov::float16( 1.0f), ov::float16(-1.0f), ov::float16( 1.0f), ov::float16( 0.5f)};
for (size_t i = 0; i < expected_result.size(); i++) {
ASSERT_FLOAT_EQ(expected_result[i], output_ptr[i]) << "i = " << i;
@ -1020,9 +1019,9 @@ TEST(fully_connected_gpu, DISABLED_fs_byx_fsv32_b12) {
// Generate random input data and set values
tests::random_generator rg(GET_SUITE_NAME);
auto input_data = rg.generate_random_4d<FLOAT16>(batch_num, input_f, input_y, input_x, -1, 1);
auto weights_data = rg.generate_random_4d<FLOAT16>(output_f, input_f, input_y, input_x, -1, 1);
auto bias_data = rg.generate_random_1d<FLOAT16>(output_f, -1, 1);
auto input_data = rg.generate_random_4d<ov::float16>(batch_num, input_f, input_y, input_x, -1, 1);
auto weights_data = rg.generate_random_4d<ov::float16>(output_f, input_f, input_y, input_x, -1, 1);
auto bias_data = rg.generate_random_1d<ov::float16>(output_f, -1, 1);
auto input_data_bfyx = flatten_4d(format::bfyx, input_data);
auto weights_data_bfyx = flatten_4d(format::bfyx, weights_data);
@ -1054,7 +1053,7 @@ TEST(fully_connected_gpu, DISABLED_fs_byx_fsv32_b12) {
auto outputs = network.execute();
auto output_prim = outputs.at("out").get_memory();
cldnn::mem_lock<FLOAT16> output_ptr(output_prim, get_test_stream());
cldnn::mem_lock<ov::float16> output_ptr(output_prim, get_test_stream());
for (size_t bi = 0; bi < batch_num; ++bi)
{
@ -1097,9 +1096,9 @@ TEST(fully_connected_gpu, DISABLED_fs_byx_fsv32_b34)
// Generate random input data and set values
tests::random_generator rg(GET_SUITE_NAME);
auto input_data = rg.generate_random_4d<FLOAT16>(batch_num, input_f, input_y, input_x, -1, 1);
auto weights_data = rg.generate_random_4d<FLOAT16>(output_f, input_f, input_y, input_x, -1, 1);
auto bias_data = rg.generate_random_1d<FLOAT16>(output_f, -1, 1);
auto input_data = rg.generate_random_4d<ov::float16>(batch_num, input_f, input_y, input_x, -1, 1);
auto weights_data = rg.generate_random_4d<ov::float16>(output_f, input_f, input_y, input_x, -1, 1);
auto bias_data = rg.generate_random_1d<ov::float16>(output_f, -1, 1);
auto input_data_bfyx = flatten_4d(format::bfyx, input_data);
auto weights_data_bfyx = flatten_4d(format::bfyx, weights_data);
@ -1131,7 +1130,7 @@ TEST(fully_connected_gpu, DISABLED_fs_byx_fsv32_b34)
auto outputs = network.execute();
auto output_prim = outputs.at("out").get_memory();
cldnn::mem_lock<FLOAT16> output_ptr(output_prim, get_test_stream());
cldnn::mem_lock<ov::float16> output_ptr(output_prim, get_test_stream());
for (size_t bi = 0; bi < batch_num; ++bi)
{
@ -1195,7 +1194,7 @@ struct fully_connected_random_test : ::testing::TestWithParam<fully_connected_te
};
using fully_connected_random_test_f32 = fully_connected_random_test<float, float, float, float>;
using fully_connected_random_test_f16 = fully_connected_random_test<FLOAT16, FLOAT16, FLOAT16, FLOAT16>;
using fully_connected_random_test_f16 = fully_connected_random_test<ov::float16, ov::float16, ov::float16, ov::float16>;
TEST_P(fully_connected_random_test_f32, basic) {
run_test();
@ -1341,7 +1340,7 @@ struct fully_connected_random_test_3d : ::testing::TestWithParam<fully_connected
using fully_connected_random_test_f32_3d = fully_connected_random_test_3d<float, float, float, float>;
using fully_connected_random_test_f16_3d = fully_connected_random_test_3d<FLOAT16, FLOAT16, FLOAT16, FLOAT16>;
using fully_connected_random_test_f16_3d = fully_connected_random_test_3d<ov::float16, ov::float16, ov::float16, ov::float16>;
using fully_connected_random_test_i8_3d = fully_connected_random_test_3d<int8_t, int8_t, int8_t, float>;
@ -1497,11 +1496,11 @@ private:
size_t output_f() { return _weights.size(); }
data_types input_data_type() {
return type_to_data_type<InputT>::value;
return ov::element::from<InputT>();
}
data_types output_data_type() {
return type_to_data_type<OutputT>::value;
return ov::element::from<OutputT>();
}
bool has_bias() { return _bias.size() > 0; }
@ -1581,7 +1580,7 @@ public:
[](tensor::value_type x) { return x != 1l; });
size_t input_rank = std::distance(input_sizes.begin(), last_dim.base());
auto fc_prim = fully_connected("fc_prim", input_info("input"), "weights", "bias", cldnn::padding(), input_rank);
fc_prim.output_data_types = {type_to_data_type<OutputT>::value};
fc_prim.output_data_types = {static_cast<ov::element::Type_t>(ov::element::from<OutputT>())};
topo.add(fc_prim);
topo.add(data("quant_input_low", quantization_input_low));
@ -2497,9 +2496,9 @@ struct dynamic_fully_connected_gpu : ::testing::TestWithParam<fully_connected_dy
std::tie(batch_sizes, input_f, output_f, fc_3d) = GetParam();
auto input_dt = cldnn::type_to_data_type<InputT>::value;
auto weights_dt = cldnn::type_to_data_type<WeightsT>::value;
auto output_dt = cldnn::type_to_data_type<OutputT>::value;
auto input_dt = ov::element::from<InputT>();
auto weights_dt = ov::element::from<WeightsT>();
auto output_dt = ov::element::from<OutputT>();
auto& engine = get_test_engine();
auto input_dyn_layout = layout{ ov::PartialShape{ ov::Dimension(), input_f }, input_dt, format::bfyx };
@ -2580,7 +2579,7 @@ struct dynamic_fully_connected_gpu : ::testing::TestWithParam<fully_connected_dy
};
using dynamic_fully_connected_gpu_f32_3d = dynamic_fully_connected_gpu<float, float, float, float>;
using dynamic_fully_connected_gpu_f16_3d = dynamic_fully_connected_gpu<FLOAT16, FLOAT16, FLOAT16, FLOAT16>;
using dynamic_fully_connected_gpu_f16_3d = dynamic_fully_connected_gpu<ov::float16, ov::float16, ov::float16, ov::float16>;
using dynamic_fully_connected_gpu_i8_3d = dynamic_fully_connected_gpu<int8_t, int8_t, int8_t, float>;
static const std::vector<ov::Dimension::value_type>
@ -2773,11 +2772,11 @@ private:
size_t output_f() { return _weights.size(); }
data_types input_data_type() {
return type_to_data_type<InputT>::value;
return ov::element::from<InputT>();
}
data_types weights_data_type() {
return type_to_data_type<WeightsT>::value;
return ov::element::from<WeightsT>();
}
bool has_bias() { return _bias.size() > 0; }
@ -2845,7 +2844,7 @@ public:
[](tensor::value_type x) { return x != 1l; });
size_t input_rank = std::distance(input_sizes.begin(), last_dim.base());
auto fc_prim = fully_connected("output", input_info("input"), "weights", "bias", cldnn::padding(), input_rank);
fc_prim.output_data_types = {type_to_data_type<WeightsT>::value};
fc_prim.output_data_types = { static_cast<ov::element::Type_t>(ov::element::from<WeightsT>()) };
topo.add(fc_prim);
ExecutionConfig config = get_test_default_config(engine);

2010
src/plugins/intel_gpu/tests/unit/test_cases/gather_elements_gpu_test.cpp
View File

File diff suppressed because it is too large Load Diff

160
src/plugins/intel_gpu/tests/unit/test_cases/gather_gpu_test.cpp
View File

@ -119,7 +119,7 @@ public:
!memcmp(reorder_output_ptr.data(), planar_output_ptr.data(), get_linear_size(shape_out) * sizeof(T_dat)));
}
};
using gather8_test_f16i32 = gather8_test<FLOAT16, int, data_types::f16, data_types::i32>;
using gather8_test_f16i32 = gather8_test<ov::float16, int, data_types::f16, data_types::i32>;
using gather8_test_f32i8 = gather8_test<float, char, data_types::f32, data_types::i8>;
using gather8_test_i32i32 = gather8_test<int, int, data_types::i32, data_types::i32>;
TEST_P(gather8_test_f16i32, gather8_test_f16i32) {}
@ -366,31 +366,31 @@ TEST(gather8_gpu_fp16, d323_axisY_bdim_m1) {
bool negative_indexes = true;
set_values(input1, {
FLOAT16(1.f), FLOAT16(2.f), FLOAT16(3.f), FLOAT16(4.f), FLOAT16(5.f), FLOAT16(6.f), FLOAT16(7.f), FLOAT16(8.f),
FLOAT16(9.f), FLOAT16(10.f), FLOAT16(11.f), FLOAT16(12.f), FLOAT16(13.f), FLOAT16(14.f), FLOAT16(15.f), FLOAT16(16.f),
FLOAT16(17.f), FLOAT16(18.f), FLOAT16(19.f), FLOAT16(20.f), FLOAT16(21.f), FLOAT16(22.f), FLOAT16(23.f), FLOAT16(24.f),
ov::float16(1.f), ov::float16(2.f), ov::float16(3.f), ov::float16(4.f), ov::float16(5.f), ov::float16(6.f), ov::float16(7.f), ov::float16(8.f),
ov::float16(9.f), ov::float16(10.f), ov::float16(11.f), ov::float16(12.f), ov::float16(13.f), ov::float16(14.f), ov::float16(15.f), ov::float16(16.f),
ov::float16(17.f), ov::float16(18.f), ov::float16(19.f), ov::float16(20.f), ov::float16(21.f), ov::float16(22.f), ov::float16(23.f), ov::float16(24.f),
FLOAT16(25.f), FLOAT16(26.f), FLOAT16(27.f), FLOAT16(28.f), FLOAT16(29.f), FLOAT16(30.f), FLOAT16(31.f), FLOAT16(32.f),
FLOAT16(33.f), FLOAT16(34.f), FLOAT16(35.f), FLOAT16(36.f), FLOAT16(37.f), FLOAT16(38.f), FLOAT16(39.f), FLOAT16(40.f),
FLOAT16(41.f), FLOAT16(42.f), FLOAT16(43.f), FLOAT16(44.f), FLOAT16(45.f), FLOAT16(46.f), FLOAT16(47.f), FLOAT16(48.f),
ov::float16(25.f), ov::float16(26.f), ov::float16(27.f), ov::float16(28.f), ov::float16(29.f), ov::float16(30.f), ov::float16(31.f), ov::float16(32.f),
ov::float16(33.f), ov::float16(34.f), ov::float16(35.f), ov::float16(36.f), ov::float16(37.f), ov::float16(38.f), ov::float16(39.f), ov::float16(40.f),
ov::float16(41.f), ov::float16(42.f), ov::float16(43.f), ov::float16(44.f), ov::float16(45.f), ov::float16(46.f), ov::float16(47.f), ov::float16(48.f),
FLOAT16(49.f), FLOAT16(50.f), FLOAT16(51.f), FLOAT16(52.f), FLOAT16(53.f), FLOAT16(54.f), FLOAT16(55.f), FLOAT16(56.f),
FLOAT16(57.f), FLOAT16(58.f), FLOAT16(59.f), FLOAT16(60.f), FLOAT16(61.f), FLOAT16(62.f), FLOAT16(63.f), FLOAT16(64.f),
FLOAT16(65.f), FLOAT16(66.f), FLOAT16(67.f), FLOAT16(68.f), FLOAT16(69.f), FLOAT16(70.f), FLOAT16(71.f), FLOAT16(72.f),
ov::float16(49.f), ov::float16(50.f), ov::float16(51.f), ov::float16(52.f), ov::float16(53.f), ov::float16(54.f), ov::float16(55.f), ov::float16(56.f),
ov::float16(57.f), ov::float16(58.f), ov::float16(59.f), ov::float16(60.f), ov::float16(61.f), ov::float16(62.f), ov::float16(63.f), ov::float16(64.f),
ov::float16(65.f), ov::float16(66.f), ov::float16(67.f), ov::float16(68.f), ov::float16(69.f), ov::float16(70.f), ov::float16(71.f), ov::float16(72.f),
FLOAT16(73.f), FLOAT16(74.f), FLOAT16(75.f), FLOAT16(76.f), FLOAT16(77.f), FLOAT16(78.f), FLOAT16(79.f), FLOAT16(80.f),
FLOAT16(81.f), FLOAT16(82.f), FLOAT16(83.f), FLOAT16(84.f), FLOAT16(85.f), FLOAT16(86.f), FLOAT16(87.f), FLOAT16(88.f),
FLOAT16(89.f), FLOAT16(90.f), FLOAT16(91.f), FLOAT16(92.f), FLOAT16(93.f), FLOAT16(94.f), FLOAT16(95.f), FLOAT16(96.f),
ov::float16(73.f), ov::float16(74.f), ov::float16(75.f), ov::float16(76.f), ov::float16(77.f), ov::float16(78.f), ov::float16(79.f), ov::float16(80.f),
ov::float16(81.f), ov::float16(82.f), ov::float16(83.f), ov::float16(84.f), ov::float16(85.f), ov::float16(86.f), ov::float16(87.f), ov::float16(88.f),
ov::float16(89.f), ov::float16(90.f), ov::float16(91.f), ov::float16(92.f), ov::float16(93.f), ov::float16(94.f), ov::float16(95.f), ov::float16(96.f),
FLOAT16(97.f), FLOAT16(98.f), FLOAT16(99.f), FLOAT16(100.f), FLOAT16(101.f), FLOAT16(102.f), FLOAT16(103.f), FLOAT16(104.f),
FLOAT16(105.f), FLOAT16(106.f), FLOAT16(107.f), FLOAT16(108.f), FLOAT16(109.f), FLOAT16(110.f), FLOAT16(111.f), FLOAT16(112.f),
FLOAT16(113.f), FLOAT16(114.f), FLOAT16(115.f), FLOAT16(116.f), FLOAT16(117.f), FLOAT16(118.f), FLOAT16(119.f), FLOAT16(120.f),
ov::float16(97.f), ov::float16(98.f), ov::float16(99.f), ov::float16(100.f), ov::float16(101.f), ov::float16(102.f), ov::float16(103.f), ov::float16(104.f),
ov::float16(105.f), ov::float16(106.f), ov::float16(107.f), ov::float16(108.f), ov::float16(109.f), ov::float16(110.f), ov::float16(111.f), ov::float16(112.f),
ov::float16(113.f), ov::float16(114.f), ov::float16(115.f), ov::float16(116.f), ov::float16(117.f), ov::float16(118.f), ov::float16(119.f), ov::float16(120.f),
FLOAT16(121.f), FLOAT16(122.f), FLOAT16(123.f), FLOAT16(124.f), FLOAT16(125.f), FLOAT16(126.f), FLOAT16(127.f), FLOAT16(128.f),
FLOAT16(129.f), FLOAT16(130.f), FLOAT16(131.f), FLOAT16(132.f), FLOAT16(133.f), FLOAT16(134.f), FLOAT16(135.f), FLOAT16(136.f),
FLOAT16(137.f), FLOAT16(138.f), FLOAT16(139.f), FLOAT16(140.f), FLOAT16(141.f), FLOAT16(142.f), FLOAT16(143.f), FLOAT16(144.f)
ov::float16(121.f), ov::float16(122.f), ov::float16(123.f), ov::float16(124.f), ov::float16(125.f), ov::float16(126.f), ov::float16(127.f), ov::float16(128.f),
ov::float16(129.f), ov::float16(130.f), ov::float16(131.f), ov::float16(132.f), ov::float16(133.f), ov::float16(134.f), ov::float16(135.f), ov::float16(136.f),
ov::float16(137.f), ov::float16(138.f), ov::float16(139.f), ov::float16(140.f), ov::float16(141.f), ov::float16(142.f), ov::float16(143.f), ov::float16(144.f)
});
set_values(input2, {
@ -490,17 +490,17 @@ TEST(gather7_gpu_fp16, d222_axisX_bdim_m1) {
int64_t batch_dim = -1;
set_values(input1, {
FLOAT16(1.f), FLOAT16(2.f), FLOAT16(3.f), FLOAT16(4.f), FLOAT16(5.f), FLOAT16(6.f), FLOAT16(7.f), FLOAT16(8.f),
FLOAT16(9.f), FLOAT16(10.f), FLOAT16(11.f), FLOAT16(12.f), FLOAT16(13.f), FLOAT16(14.f), FLOAT16(15.f), FLOAT16(16.f),
ov::float16(1.f), ov::float16(2.f), ov::float16(3.f), ov::float16(4.f), ov::float16(5.f), ov::float16(6.f), ov::float16(7.f), ov::float16(8.f),
ov::float16(9.f), ov::float16(10.f), ov::float16(11.f), ov::float16(12.f), ov::float16(13.f), ov::float16(14.f), ov::float16(15.f), ov::float16(16.f),
FLOAT16(17.f), FLOAT16(18.f), FLOAT16(19.f), FLOAT16(20.f), FLOAT16(21.f), FLOAT16(22.f), FLOAT16(23.f), FLOAT16(24.f),
FLOAT16(25.f), FLOAT16(26.f), FLOAT16(27.f), FLOAT16(28.f), FLOAT16(29.f), FLOAT16(30.f), FLOAT16(31.f), FLOAT16(32.f),
ov::float16(17.f), ov::float16(18.f), ov::float16(19.f), ov::float16(20.f), ov::float16(21.f), ov::float16(22.f), ov::float16(23.f), ov::float16(24.f),
ov::float16(25.f), ov::float16(26.f), ov::float16(27.f), ov::float16(28.f), ov::float16(29.f), ov::float16(30.f), ov::float16(31.f), ov::float16(32.f),
FLOAT16(33.f), FLOAT16(34.f), FLOAT16(35.f), FLOAT16(36.f), FLOAT16(37.f), FLOAT16(38.f), FLOAT16(39.f), FLOAT16(40.f),
FLOAT16(41.f), FLOAT16(42.f), FLOAT16(43.f), FLOAT16(44.f), FLOAT16(45.f), FLOAT16(46.f), FLOAT16(47.f), FLOAT16(48.f),
ov::float16(33.f), ov::float16(34.f), ov::float16(35.f), ov::float16(36.f), ov::float16(37.f), ov::float16(38.f), ov::float16(39.f), ov::float16(40.f),
ov::float16(41.f), ov::float16(42.f), ov::float16(43.f), ov::float16(44.f), ov::float16(45.f), ov::float16(46.f), ov::float16(47.f), ov::float16(48.f),
FLOAT16(49.f), FLOAT16(50.f), FLOAT16(51.f), FLOAT16(52.f), FLOAT16(53.f), FLOAT16(54.f), FLOAT16(55.f), FLOAT16(56.f),
FLOAT16(57.f), FLOAT16(58.f), FLOAT16(59.f), FLOAT16(60.f), FLOAT16(61.f), FLOAT16(62.f), FLOAT16(63.f), FLOAT16(64.f),
ov::float16(49.f), ov::float16(50.f), ov::float16(51.f), ov::float16(52.f), ov::float16(53.f), ov::float16(54.f), ov::float16(55.f), ov::float16(56.f),
ov::float16(57.f), ov::float16(58.f), ov::float16(59.f), ov::float16(60.f), ov::float16(61.f), ov::float16(62.f), ov::float16(63.f), ov::float16(64.f),
});
set_values(input2, {
@ -584,31 +584,31 @@ TEST(gather7_gpu_fp16, d323_axisY_bdim_m1) {
int64_t batch_dim = -1;
set_values(input1, {
FLOAT16(1.f), FLOAT16(2.f), FLOAT16(3.f), FLOAT16(4.f), FLOAT16(5.f), FLOAT16(6.f), FLOAT16(7.f), FLOAT16(8.f),
FLOAT16(9.f), FLOAT16(10.f), FLOAT16(11.f), FLOAT16(12.f), FLOAT16(13.f), FLOAT16(14.f), FLOAT16(15.f), FLOAT16(16.f),
FLOAT16(17.f), FLOAT16(18.f), FLOAT16(19.f), FLOAT16(20.f), FLOAT16(21.f), FLOAT16(22.f), FLOAT16(23.f), FLOAT16(24.f),
ov::float16(1.f), ov::float16(2.f), ov::float16(3.f), ov::float16(4.f), ov::float16(5.f), ov::float16(6.f), ov::float16(7.f), ov::float16(8.f),
ov::float16(9.f), ov::float16(10.f), ov::float16(11.f), ov::float16(12.f), ov::float16(13.f), ov::float16(14.f), ov::float16(15.f), ov::float16(16.f),
ov::float16(17.f), ov::float16(18.f), ov::float16(19.f), ov::float16(20.f), ov::float16(21.f), ov::float16(22.f), ov::float16(23.f), ov::float16(24.f),
FLOAT16(25.f), FLOAT16(26.f), FLOAT16(27.f), FLOAT16(28.f), FLOAT16(29.f), FLOAT16(30.f), FLOAT16(31.f), FLOAT16(32.f),
FLOAT16(33.f), FLOAT16(34.f), FLOAT16(35.f), FLOAT16(36.f), FLOAT16(37.f), FLOAT16(38.f), FLOAT16(39.f), FLOAT16(40.f),
FLOAT16(41.f), FLOAT16(42.f), FLOAT16(43.f), FLOAT16(44.f), FLOAT16(45.f), FLOAT16(46.f), FLOAT16(47.f), FLOAT16(48.f),
ov::float16(25.f), ov::float16(26.f), ov::float16(27.f), ov::float16(28.f), ov::float16(29.f), ov::float16(30.f), ov::float16(31.f), ov::float16(32.f),
ov::float16(33.f), ov::float16(34.f), ov::float16(35.f), ov::float16(36.f), ov::float16(37.f), ov::float16(38.f), ov::float16(39.f), ov::float16(40.f),
ov::float16(41.f), ov::float16(42.f), ov::float16(43.f), ov::float16(44.f), ov::float16(45.f), ov::float16(46.f), ov::float16(47.f), ov::float16(48.f),
FLOAT16(49.f), FLOAT16(50.f), FLOAT16(51.f), FLOAT16(52.f), FLOAT16(53.f), FLOAT16(54.f), FLOAT16(55.f), FLOAT16(56.f),
FLOAT16(57.f), FLOAT16(58.f), FLOAT16(59.f), FLOAT16(60.f), FLOAT16(61.f), FLOAT16(62.f), FLOAT16(63.f), FLOAT16(64.f),
FLOAT16(65.f), FLOAT16(66.f), FLOAT16(67.f), FLOAT16(68.f), FLOAT16(69.f), FLOAT16(70.f), FLOAT16(71.f), FLOAT16(72.f),
ov::float16(49.f), ov::float16(50.f), ov::float16(51.f), ov::float16(52.f), ov::float16(53.f), ov::float16(54.f), ov::float16(55.f), ov::float16(56.f),
ov::float16(57.f), ov::float16(58.f), ov::float16(59.f), ov::float16(60.f), ov::float16(61.f), ov::float16(62.f), ov::float16(63.f), ov::float16(64.f),
ov::float16(65.f), ov::float16(66.f), ov::float16(67.f), ov::float16(68.f), ov::float16(69.f), ov::float16(70.f), ov::float16(71.f), ov::float16(72.f),
FLOAT16(73.f), FLOAT16(74.f), FLOAT16(75.f), FLOAT16(76.f), FLOAT16(77.f), FLOAT16(78.f), FLOAT16(79.f), FLOAT16(80.f),
FLOAT16(81.f), FLOAT16(82.f), FLOAT16(83.f), FLOAT16(84.f), FLOAT16(85.f), FLOAT16(86.f), FLOAT16(87.f), FLOAT16(88.f),
FLOAT16(89.f), FLOAT16(90.f), FLOAT16(91.f), FLOAT16(92.f), FLOAT16(93.f), FLOAT16(94.f), FLOAT16(95.f), FLOAT16(96.f),
ov::float16(73.f), ov::float16(74.f), ov::float16(75.f), ov::float16(76.f), ov::float16(77.f), ov::float16(78.f), ov::float16(79.f), ov::float16(80.f),
ov::float16(81.f), ov::float16(82.f), ov::float16(83.f), ov::float16(84.f), ov::float16(85.f), ov::float16(86.f), ov::float16(87.f), ov::float16(88.f),
ov::float16(89.f), ov::float16(90.f), ov::float16(91.f), ov::float16(92.f), ov::float16(93.f), ov::float16(94.f), ov::float16(95.f), ov::float16(96.f),
FLOAT16(97.f), FLOAT16(98.f), FLOAT16(99.f), FLOAT16(100.f), FLOAT16(101.f), FLOAT16(102.f), FLOAT16(103.f), FLOAT16(104.f),
FLOAT16(105.f), FLOAT16(106.f), FLOAT16(107.f), FLOAT16(108.f), FLOAT16(109.f), FLOAT16(110.f), FLOAT16(111.f), FLOAT16(112.f),
FLOAT16(113.f), FLOAT16(114.f), FLOAT16(115.f), FLOAT16(116.f), FLOAT16(117.f), FLOAT16(118.f), FLOAT16(119.f), FLOAT16(120.f),
ov::float16(97.f), ov::float16(98.f), ov::float16(99.f), ov::float16(100.f), ov::float16(101.f), ov::float16(102.f), ov::float16(103.f), ov::float16(104.f),
ov::float16(105.f), ov::float16(106.f), ov::float16(107.f), ov::float16(108.f), ov::float16(109.f), ov::float16(110.f), ov::float16(111.f), ov::float16(112.f),
ov::float16(113.f), ov::float16(114.f), ov::float16(115.f), ov::float16(116.f), ov::float16(117.f), ov::float16(118.f), ov::float16(119.f), ov::float16(120.f),
FLOAT16(121.f), FLOAT16(122.f), FLOAT16(123.f), FLOAT16(124.f), FLOAT16(125.f), FLOAT16(126.f), FLOAT16(127.f), FLOAT16(128.f),
FLOAT16(129.f), FLOAT16(130.f), FLOAT16(131.f), FLOAT16(132.f), FLOAT16(133.f), FLOAT16(134.f), FLOAT16(135.f), FLOAT16(136.f),
FLOAT16(137.f), FLOAT16(138.f), FLOAT16(139.f), FLOAT16(140.f), FLOAT16(141.f), FLOAT16(142.f), FLOAT16(143.f), FLOAT16(144.f)
ov::float16(121.f), ov::float16(122.f), ov::float16(123.f), ov::float16(124.f), ov::float16(125.f), ov::float16(126.f), ov::float16(127.f), ov::float16(128.f),
ov::float16(129.f), ov::float16(130.f), ov::float16(131.f), ov::float16(132.f), ov::float16(133.f), ov::float16(134.f), ov::float16(135.f), ov::float16(136.f),
ov::float16(137.f), ov::float16(138.f), ov::float16(139.f), ov::float16(140.f), ov::float16(141.f), ov::float16(142.f), ov::float16(143.f), ov::float16(144.f)
});
set_values(input2, {
@ -702,21 +702,21 @@ TEST(gather7_gpu_fp16, d44_axisY_bdim1) {
int64_t batch_dim = 1;
set_values(input1, {
FLOAT16(84.f), FLOAT16( 7.f), FLOAT16(10.f), FLOAT16(69.f), FLOAT16(13.f),
FLOAT16(47.f), FLOAT16(75.f), FLOAT16( 8.f), FLOAT16(65.f), FLOAT16(28.f),
FLOAT16( 5.f), FLOAT16(12.f), FLOAT16(56.f), FLOAT16(54.f), FLOAT16( 9.f),
ov::float16(84.f), ov::float16( 7.f), ov::float16(10.f), ov::float16(69.f), ov::float16(13.f),
ov::float16(47.f), ov::float16(75.f), ov::float16( 8.f), ov::float16(65.f), ov::float16(28.f),
ov::float16( 5.f), ov::float16(12.f), ov::float16(56.f), ov::float16(54.f), ov::float16( 9.f),
FLOAT16(31.f), FLOAT16(12.f), FLOAT16(71.f), FLOAT16(55.f), FLOAT16( 8.f),
FLOAT16(73.f), FLOAT16(16.f), FLOAT16(29.f), FLOAT16(81.f), FLOAT16(81.f),
FLOAT16(75.f), FLOAT16( 8.f), FLOAT16(74.f), FLOAT16(75.f), FLOAT16(51.f),
ov::float16(31.f), ov::float16(12.f), ov::float16(71.f), ov::float16(55.f), ov::float16( 8.f),
ov::float16(73.f), ov::float16(16.f), ov::float16(29.f), ov::float16(81.f), ov::float16(81.f),
ov::float16(75.f), ov::float16( 8.f), ov::float16(74.f), ov::float16(75.f), ov::float16(51.f),
FLOAT16( 7.f), FLOAT16(29.f), FLOAT16( 6.f), FLOAT16(72.f), FLOAT16(18.f),
FLOAT16(38.f), FLOAT16(54.f), FLOAT16(19.f), FLOAT16(70.f), FLOAT16(16.f),
FLOAT16(74.f), FLOAT16(40.f), FLOAT16(72.f), FLOAT16(88.f), FLOAT16(24.f),
ov::float16( 7.f), ov::float16(29.f), ov::float16( 6.f), ov::float16(72.f), ov::float16(18.f),
ov::float16(38.f), ov::float16(54.f), ov::float16(19.f), ov::float16(70.f), ov::float16(16.f),
ov::float16(74.f), ov::float16(40.f), ov::float16(72.f), ov::float16(88.f), ov::float16(24.f),
FLOAT16(14.f), FLOAT16(75.f), FLOAT16(74.f), FLOAT16(82.f), FLOAT16(25.f),
FLOAT16(48.f), FLOAT16(13.f), FLOAT16(71.f), FLOAT16(92.f), FLOAT16( 9.f),
FLOAT16(73.f), FLOAT16( 8.f), FLOAT16(80.f), FLOAT16(27.f), FLOAT16(64.f)
ov::float16(14.f), ov::float16(75.f), ov::float16(74.f), ov::float16(82.f), ov::float16(25.f),
ov::float16(48.f), ov::float16(13.f), ov::float16(71.f), ov::float16(92.f), ov::float16( 9.f),
ov::float16(73.f), ov::float16( 8.f), ov::float16(80.f), ov::float16(27.f), ov::float16(64.f)
});
set_values(input2, {
@ -791,9 +791,9 @@ TEST(gather7_gpu_fp16, d32_axisF_bdim_m1) {
size_t batch_dim = -1;
set_values(input1, {
FLOAT16(1.f), FLOAT16(2.f),
FLOAT16(3.f), FLOAT16(4.f),
FLOAT16(5.f), FLOAT16(6.f)
ov::float16(1.f), ov::float16(2.f),
ov::float16(3.f), ov::float16(4.f),
ov::float16(5.f), ov::float16(6.f)
});
set_values(input2, {
@ -854,9 +854,9 @@ TEST(gather7_gpu_fp16, d32_axisF_bdim1) {
int64_t batch_dim = 1;
set_values(input1, {
FLOAT16(1.f), FLOAT16(2.f),
FLOAT16(3.f), FLOAT16(4.f),
FLOAT16(5.f), FLOAT16(6.f)
ov::float16(1.f), ov::float16(2.f),
ov::float16(3.f), ov::float16(4.f),
ov::float16(5.f), ov::float16(6.f)
});
set_values(input2, {
@ -916,9 +916,9 @@ TEST(gather7_gpu_fp16, d32_axisF_bdim0) {
size_t batch_dim = 0;
set_values(input1, {
FLOAT16(1.f), FLOAT16(2.f),
FLOAT16(3.f), FLOAT16(4.f),
FLOAT16(5.f), FLOAT16(6.f)
ov::float16(1.f), ov::float16(2.f),
ov::float16(3.f), ov::float16(4.f),
ov::float16(5.f), ov::float16(6.f)
});
set_values(input2, {
@ -985,8 +985,8 @@ TEST(gather_gpu_fp16, d14_axisB) {
int64_t axis = 0;
set_values(input1, {
FLOAT16(1.0f), FLOAT16(2.0f),
FLOAT16(3.0f), FLOAT16(4.0f)
ov::float16(1.0f), ov::float16(2.0f),
ov::float16(3.0f), ov::float16(4.0f)
});
set_values(input2, {
@ -1044,11 +1044,11 @@ TEST(gather_gpu_fp16, d222_axisB) {
int64_t axis = 0;
set_values(input1, {
FLOAT16(1.f), FLOAT16(2.f), FLOAT16(3.f),
FLOAT16(4.f), FLOAT16(5.f), FLOAT16(6.f),
ov::float16(1.f), ov::float16(2.f), ov::float16(3.f),
ov::float16(4.f), ov::float16(5.f), ov::float16(6.f),
FLOAT16(7.f), FLOAT16(8.f), FLOAT16(9.f),
FLOAT16(10.f), FLOAT16(11.f), FLOAT16(12.f)
ov::float16(7.f), ov::float16(8.f), ov::float16(9.f),
ov::float16(10.f), ov::float16(11.f), ov::float16(12.f)
});
set_values(input2, {
@ -1106,11 +1106,11 @@ TEST(gather_gpu_fp16, d22_axisY) {
int64_t axis = 2;
set_values(input1, {
FLOAT16(1.f), FLOAT16(2.f), FLOAT16(3.f),
FLOAT16(4.f), FLOAT16(5.f), FLOAT16(6.f),
ov::float16(1.f), ov::float16(2.f), ov::float16(3.f),
ov::float16(4.f), ov::float16(5.f), ov::float16(6.f),
FLOAT16(7.f), FLOAT16(8.f), FLOAT16(9.f),
FLOAT16(10.f), FLOAT16(11.f), FLOAT16(12.f)
ov::float16(7.f), ov::float16(8.f), ov::float16(9.f),
ov::float16(10.f), ov::float16(11.f), ov::float16(12.f)
});
set_values(input2, {
@ -1167,11 +1167,11 @@ TEST(gather_gpu_fp16, d22_axisF) {
int64_t axis = 1;
set_values(input1, {
FLOAT16(1.f), FLOAT16(2.f), FLOAT16(3.f),
FLOAT16(4.f), FLOAT16(5.f), FLOAT16(6.f),
ov::float16(1.f), ov::float16(2.f), ov::float16(3.f),
ov::float16(4.f), ov::float16(5.f), ov::float16(6.f),
FLOAT16(7.f), FLOAT16(8.f), FLOAT16(9.f),
FLOAT16(10.f), FLOAT16(11.f), FLOAT16(12.f)
ov::float16(7.f), ov::float16(8.f), ov::float16(9.f),
ov::float16(10.f), ov::float16(11.f), ov::float16(12.f)
});
set_values(input2, {

592
src/plugins/intel_gpu/tests/unit/test_cases/gather_nd_gpu_test.cpp
View File

@ -106,33 +106,33 @@ TEST(gather_nd_gpu_fp16, d23322_i231312_ir6_batch2) {
// expected output dim: v5{6,1,3,1,2}, v8{2,3,1,3,1,2}
set_values(input0, {
FLOAT16(11), FLOAT16(12), FLOAT16(13), FLOAT16(14), FLOAT16(15), FLOAT16(16), FLOAT16(11), FLOAT16(12), FLOAT16(13), FLOAT16(14), FLOAT16(15), FLOAT16(16),
FLOAT16(21), FLOAT16(22), FLOAT16(23), FLOAT16(24), FLOAT16(25), FLOAT16(26), FLOAT16(21), FLOAT16(22), FLOAT16(23), FLOAT16(24), FLOAT16(25), FLOAT16(26),
FLOAT16(31), FLOAT16(32), FLOAT16(33), FLOAT16(34), FLOAT16(35), FLOAT16(36), FLOAT16(31), FLOAT16(32), FLOAT16(33), FLOAT16(34), FLOAT16(35), FLOAT16(36),
ov::float16(11), ov::float16(12), ov::float16(13), ov::float16(14), ov::float16(15), ov::float16(16), ov::float16(11), ov::float16(12), ov::float16(13), ov::float16(14), ov::float16(15), ov::float16(16),
ov::float16(21), ov::float16(22), ov::float16(23), ov::float16(24), ov::float16(25), ov::float16(26), ov::float16(21), ov::float16(22), ov::float16(23), ov::float16(24), ov::float16(25), ov::float16(26),
ov::float16(31), ov::float16(32), ov::float16(33), ov::float16(34), ov::float16(35), ov::float16(36), ov::float16(31), ov::float16(32), ov::float16(33), ov::float16(34), ov::float16(35), ov::float16(36),
FLOAT16(11), FLOAT16(12), FLOAT16(13), FLOAT16(14), FLOAT16(15), FLOAT16(16), FLOAT16(11), FLOAT16(12), FLOAT16(13), FLOAT16(14), FLOAT16(15), FLOAT16(16),
FLOAT16(21), FLOAT16(22), FLOAT16(23), FLOAT16(24), FLOAT16(25), FLOAT16(26), FLOAT16(21), FLOAT16(22), FLOAT16(23), FLOAT16(24), FLOAT16(25), FLOAT16(26),
FLOAT16(31), FLOAT16(32), FLOAT16(33), FLOAT16(34), FLOAT16(35), FLOAT16(36), FLOAT16(31), FLOAT16(32), FLOAT16(33), FLOAT16(34), FLOAT16(35), FLOAT16(36),
ov::float16(11), ov::float16(12), ov::float16(13), ov::float16(14), ov::float16(15), ov::float16(16), ov::float16(11), ov::float16(12), ov::float16(13), ov::float16(14), ov::float16(15), ov::float16(16),
ov::float16(21), ov::float16(22), ov::float16(23), ov::float16(24), ov::float16(25), ov::float16(26), ov::float16(21), ov::float16(22), ov::float16(23), ov::float16(24), ov::float16(25), ov::float16(26),
ov::float16(31), ov::float16(32), ov::float16(33), ov::float16(34), ov::float16(35), ov::float16(36), ov::float16(31), ov::float16(32), ov::float16(33), ov::float16(34), ov::float16(35), ov::float16(36),
});
set_values(input1, {
FLOAT16(2), FLOAT16(1), FLOAT16(1), FLOAT16(1), FLOAT16(1), FLOAT16(1),
FLOAT16(1), FLOAT16(0), FLOAT16(2), FLOAT16(0), FLOAT16(2), FLOAT16(0),
FLOAT16(0), FLOAT16(1), FLOAT16(0), FLOAT16(1), FLOAT16(0), FLOAT16(1),
ov::float16(2), ov::float16(1), ov::float16(1), ov::float16(1), ov::float16(1), ov::float16(1),
ov::float16(1), ov::float16(0), ov::float16(2), ov::float16(0), ov::float16(2), ov::float16(0),
ov::float16(0), ov::float16(1), ov::float16(0), ov::float16(1), ov::float16(0), ov::float16(1),
FLOAT16(2), FLOAT16(0), FLOAT16(1), FLOAT16(0), FLOAT16(1), FLOAT16(0),
FLOAT16(1), FLOAT16(1), FLOAT16(2), FLOAT16(1), FLOAT16(2), FLOAT16(1),
FLOAT16(0), FLOAT16(0), FLOAT16(1), FLOAT16(0), FLOAT16(2), FLOAT16(0),
ov::float16(2), ov::float16(0), ov::float16(1), ov::float16(0), ov::float16(1), ov::float16(0),
ov::float16(1), ov::float16(1), ov::float16(2), ov::float16(1), ov::float16(2), ov::float16(1),
ov::float16(0), ov::float16(0), ov::float16(1), ov::float16(0), ov::float16(2), ov::float16(0),
});
std::vector<float> expected_results = {
FLOAT16(15), FLOAT16(16), FLOAT16(11), FLOAT16(12), FLOAT16(11), FLOAT16(12),
FLOAT16(25), FLOAT16(26), FLOAT16(23), FLOAT16(24), FLOAT16(23), FLOAT16(24),
FLOAT16(33), FLOAT16(34), FLOAT16(33), FLOAT16(34), FLOAT16(33), FLOAT16(34),
ov::float16(15), ov::float16(16), ov::float16(11), ov::float16(12), ov::float16(11), ov::float16(12),
ov::float16(25), ov::float16(26), ov::float16(23), ov::float16(24), ov::float16(23), ov::float16(24),
ov::float16(33), ov::float16(34), ov::float16(33), ov::float16(34), ov::float16(33), ov::float16(34),
FLOAT16(13), FLOAT16(14), FLOAT16(15), FLOAT16(16), FLOAT16(15), FLOAT16(16),
FLOAT16(21), FLOAT16(22), FLOAT16(25), FLOAT16(26), FLOAT16(25), FLOAT16(26),
FLOAT16(31), FLOAT16(32), FLOAT16(35), FLOAT16(36), FLOAT16(33), FLOAT16(34),
ov::float16(13), ov::float16(14), ov::float16(15), ov::float16(16), ov::float16(15), ov::float16(16),
ov::float16(21), ov::float16(22), ov::float16(25), ov::float16(26), ov::float16(25), ov::float16(26),
ov::float16(31), ov::float16(32), ov::float16(35), ov::float16(36), ov::float16(33), ov::float16(34),
};
DoTestV5(engine, input0, input1, expected_results, indices_rank, batch_dims, format::bfzyx, {6, 1, 2, 1, 3});
@ -149,33 +149,33 @@ TEST(gather_nd_gpu_fp16, d231322_i231321_ir6_batch5) {
// expected output dim: v5{36}, v8{2, 3, 2, 3, 1}
set_values(input0, {
FLOAT16(11), FLOAT16(12), FLOAT16(13), FLOAT16(14), FLOAT16(15), FLOAT16(16), FLOAT16(17), FLOAT16(18), FLOAT16(19), FLOAT16(10), FLOAT16(21), FLOAT16(18),
FLOAT16(21), FLOAT16(22), FLOAT16(23), FLOAT16(24), FLOAT16(25), FLOAT16(26), FLOAT16(27), FLOAT16(28), FLOAT16(29), FLOAT16(20), FLOAT16(27), FLOAT16(28),
FLOAT16(31), FLOAT16(32), FLOAT16(33), FLOAT16(34), FLOAT16(35), FLOAT16(36), FLOAT16(37), FLOAT16(38), FLOAT16(39), FLOAT16(30), FLOAT16(31), FLOAT16(30),
ov::float16(11), ov::float16(12), ov::float16(13), ov::float16(14), ov::float16(15), ov::float16(16), ov::float16(17), ov::float16(18), ov::float16(19), ov::float16(10), ov::float16(21), ov::float16(18),
ov::float16(21), ov::float16(22), ov::float16(23), ov::float16(24), ov::float16(25), ov::float16(26), ov::float16(27), ov::float16(28), ov::float16(29), ov::float16(20), ov::float16(27), ov::float16(28),
ov::float16(31), ov::float16(32), ov::float16(33), ov::float16(34), ov::float16(35), ov::float16(36), ov::float16(37), ov::float16(38), ov::float16(39), ov::float16(30), ov::float16(31), ov::float16(30),
FLOAT16(11), FLOAT16(12), FLOAT16(13), FLOAT16(14), FLOAT16(15), FLOAT16(16), FLOAT16(17), FLOAT16(18), FLOAT16(19), FLOAT16(10), FLOAT16(17), FLOAT16(18),
FLOAT16(21), FLOAT16(22), FLOAT16(23), FLOAT16(24), FLOAT16(25), FLOAT16(26), FLOAT16(27), FLOAT16(28), FLOAT16(29), FLOAT16(20), FLOAT16(27), FLOAT16(28),
FLOAT16(31), FLOAT16(32), FLOAT16(33), FLOAT16(34), FLOAT16(35), FLOAT16(36), FLOAT16(37), FLOAT16(38), FLOAT16(39), FLOAT16(30), FLOAT16(29), FLOAT16(30),
ov::float16(11), ov::float16(12), ov::float16(13), ov::float16(14), ov::float16(15), ov::float16(16), ov::float16(17), ov::float16(18), ov::float16(19), ov::float16(10), ov::float16(17), ov::float16(18),
ov::float16(21), ov::float16(22), ov::float16(23), ov::float16(24), ov::float16(25), ov::float16(26), ov::float16(27), ov::float16(28), ov::float16(29), ov::float16(20), ov::float16(27), ov::float16(28),
ov::float16(31), ov::float16(32), ov::float16(33), ov::float16(34), ov::float16(35), ov::float16(36), ov::float16(37), ov::float16(38), ov::float16(39), ov::float16(30), ov::float16(29), ov::float16(30),
});
set_values(input1, {
FLOAT16(1), FLOAT16(1), FLOAT16(1), FLOAT16(1), FLOAT16(1), FLOAT16(1),
FLOAT16(0), FLOAT16(0), FLOAT16(0), FLOAT16(0), FLOAT16(0), FLOAT16(0),
FLOAT16(1), FLOAT16(0), FLOAT16(0), FLOAT16(1), FLOAT16(1), FLOAT16(0),
ov::float16(1), ov::float16(1), ov::float16(1), ov::float16(1), ov::float16(1), ov::float16(1),
ov::float16(0), ov::float16(0), ov::float16(0), ov::float16(0), ov::float16(0), ov::float16(0),
ov::float16(1), ov::float16(0), ov::float16(0), ov::float16(1), ov::float16(1), ov::float16(0),
FLOAT16(1), FLOAT16(1), FLOAT16(1), FLOAT16(1), FLOAT16(1), FLOAT16(1),
FLOAT16(0), FLOAT16(0), FLOAT16(0), FLOAT16(0), FLOAT16(0), FLOAT16(0),
FLOAT16(1), FLOAT16(0), FLOAT16(0), FLOAT16(1), FLOAT16(1), FLOAT16(0),
ov::float16(1), ov::float16(1), ov::float16(1), ov::float16(1), ov::float16(1), ov::float16(1),
ov::float16(0), ov::float16(0), ov::float16(0), ov::float16(0), ov::float16(0), ov::float16(0),
ov::float16(1), ov::float16(0), ov::float16(0), ov::float16(1), ov::float16(1), ov::float16(0),
});
std::vector<float> expected_results = {
FLOAT16(12), FLOAT16(14), FLOAT16(16), FLOAT16(18), FLOAT16(10), FLOAT16(18),
FLOAT16(21), FLOAT16(23), FLOAT16(25), FLOAT16(27), FLOAT16(29), FLOAT16(27),
FLOAT16(32), FLOAT16(33), FLOAT16(35), FLOAT16(38), FLOAT16(30), FLOAT16(31),
ov::float16(12), ov::float16(14), ov::float16(16), ov::float16(18), ov::float16(10), ov::float16(18),
ov::float16(21), ov::float16(23), ov::float16(25), ov::float16(27), ov::float16(29), ov::float16(27),
ov::float16(32), ov::float16(33), ov::float16(35), ov::float16(38), ov::float16(30), ov::float16(31),
FLOAT16(12), FLOAT16(14), FLOAT16(16), FLOAT16(18), FLOAT16(10), FLOAT16(18),
FLOAT16(21), FLOAT16(23), FLOAT16(25), FLOAT16(27), FLOAT16(29), FLOAT16(27),
FLOAT16(32), FLOAT16(33), FLOAT16(35), FLOAT16(38), FLOAT16(30), FLOAT16(29),
ov::float16(12), ov::float16(14), ov::float16(16), ov::float16(18), ov::float16(10), ov::float16(18),
ov::float16(21), ov::float16(23), ov::float16(25), ov::float16(27), ov::float16(29), ov::float16(27),
ov::float16(32), ov::float16(33), ov::float16(35), ov::float16(38), ov::float16(30), ov::float16(29),
};
DoTestV5(engine, input0, input1, expected_results, indices_rank, batch_dims, format::bfyx, {36, 1, 1, 1});
@ -192,33 +192,33 @@ TEST(gather_nd_gpu_fp16, d23322_i23321_ir5_batch4) {
// expected output dim: v5{36}, v8{2,3,2,3}
set_values(input0, {
FLOAT16(11), FLOAT16(12), FLOAT16(13), FLOAT16(14), FLOAT16(15), FLOAT16(16), FLOAT16(17), FLOAT16(18), FLOAT16(19), FLOAT16(10), FLOAT16(21), FLOAT16(18),
FLOAT16(21), FLOAT16(22), FLOAT16(23), FLOAT16(24), FLOAT16(25), FLOAT16(26), FLOAT16(27), FLOAT16(28), FLOAT16(29), FLOAT16(20), FLOAT16(27), FLOAT16(28),
FLOAT16(31), FLOAT16(32), FLOAT16(33), FLOAT16(34), FLOAT16(35), FLOAT16(36), FLOAT16(37), FLOAT16(38), FLOAT16(39), FLOAT16(30), FLOAT16(31), FLOAT16(30),
ov::float16(11), ov::float16(12), ov::float16(13), ov::float16(14), ov::float16(15), ov::float16(16), ov::float16(17), ov::float16(18), ov::float16(19), ov::float16(10), ov::float16(21), ov::float16(18),
ov::float16(21), ov::float16(22), ov::float16(23), ov::float16(24), ov::float16(25), ov::float16(26), ov::float16(27), ov::float16(28), ov::float16(29), ov::float16(20), ov::float16(27), ov::float16(28),
ov::float16(31), ov::float16(32), ov::float16(33), ov::float16(34), ov::float16(35), ov::float16(36), ov::float16(37), ov::float16(38), ov::float16(39), ov::float16(30), ov::float16(31), ov::float16(30),
FLOAT16(11), FLOAT16(12), FLOAT16(13), FLOAT16(14), FLOAT16(15), FLOAT16(16), FLOAT16(17), FLOAT16(18), FLOAT16(19), FLOAT16(10), FLOAT16(17), FLOAT16(18),
FLOAT16(21), FLOAT16(22), FLOAT16(23), FLOAT16(24), FLOAT16(25), FLOAT16(26), FLOAT16(27), FLOAT16(28), FLOAT16(29), FLOAT16(20), FLOAT16(27), FLOAT16(28),
FLOAT16(31), FLOAT16(32), FLOAT16(33), FLOAT16(34), FLOAT16(35), FLOAT16(36), FLOAT16(37), FLOAT16(38), FLOAT16(39), FLOAT16(30), FLOAT16(29), FLOAT16(30),
ov::float16(11), ov::float16(12), ov::float16(13), ov::float16(14), ov::float16(15), ov::float16(16), ov::float16(17), ov::float16(18), ov::float16(19), ov::float16(10), ov::float16(17), ov::float16(18),
ov::float16(21), ov::float16(22), ov::float16(23), ov::float16(24), ov::float16(25), ov::float16(26), ov::float16(27), ov::float16(28), ov::float16(29), ov::float16(20), ov::float16(27), ov::float16(28),
ov::float16(31), ov::float16(32), ov::float16(33), ov::float16(34), ov::float16(35), ov::float16(36), ov::float16(37), ov::float16(38), ov::float16(39), ov::float16(30), ov::float16(29), ov::float16(30),
});
set_values(input1, {
FLOAT16(1), FLOAT16(1), FLOAT16(1), FLOAT16(1), FLOAT16(1), FLOAT16(1),
FLOAT16(0), FLOAT16(0), FLOAT16(0), FLOAT16(0), FLOAT16(0), FLOAT16(0),
FLOAT16(1), FLOAT16(0), FLOAT16(0), FLOAT16(1), FLOAT16(1), FLOAT16(0),
ov::float16(1), ov::float16(1), ov::float16(1), ov::float16(1), ov::float16(1), ov::float16(1),
ov::float16(0), ov::float16(0), ov::float16(0), ov::float16(0), ov::float16(0), ov::float16(0),
ov::float16(1), ov::float16(0), ov::float16(0), ov::float16(1), ov::float16(1), ov::float16(0),
FLOAT16(1), FLOAT16(1), FLOAT16(1), FLOAT16(1), FLOAT16(1), FLOAT16(1),
FLOAT16(0), FLOAT16(0), FLOAT16(0), FLOAT16(0), FLOAT16(0), FLOAT16(0),
FLOAT16(1), FLOAT16(0), FLOAT16(0), FLOAT16(1), FLOAT16(1), FLOAT16(0),
ov::float16(1), ov::float16(1), ov::float16(1), ov::float16(1), ov::float16(1), ov::float16(1),
ov::float16(0), ov::float16(0), ov::float16(0), ov::float16(0), ov::float16(0), ov::float16(0),
ov::float16(1), ov::float16(0), ov::float16(0), ov::float16(1), ov::float16(1), ov::float16(0),
});
std::vector<float> expected_results = {
FLOAT16(12), FLOAT16(14), FLOAT16(16), FLOAT16(18), FLOAT16(10), FLOAT16(18),
FLOAT16(21), FLOAT16(23), FLOAT16(25), FLOAT16(27), FLOAT16(29), FLOAT16(27),
FLOAT16(32), FLOAT16(33), FLOAT16(35), FLOAT16(38), FLOAT16(30), FLOAT16(31),
ov::float16(12), ov::float16(14), ov::float16(16), ov::float16(18), ov::float16(10), ov::float16(18),
ov::float16(21), ov::float16(23), ov::float16(25), ov::float16(27), ov::float16(29), ov::float16(27),
ov::float16(32), ov::float16(33), ov::float16(35), ov::float16(38), ov::float16(30), ov::float16(31),
FLOAT16(12), FLOAT16(14), FLOAT16(16), FLOAT16(18), FLOAT16(10), FLOAT16(18),
FLOAT16(21), FLOAT16(23), FLOAT16(25), FLOAT16(27), FLOAT16(29), FLOAT16(27),
FLOAT16(32), FLOAT16(33), FLOAT16(35), FLOAT16(38), FLOAT16(30), FLOAT16(29),
ov::float16(12), ov::float16(14), ov::float16(16), ov::float16(18), ov::float16(10), ov::float16(18),
ov::float16(21), ov::float16(23), ov::float16(25), ov::float16(27), ov::float16(29), ov::float16(27),
ov::float16(32), ov::float16(33), ov::float16(35), ov::float16(38), ov::float16(30), ov::float16(29),
};
DoTestV5(engine, input0, input1, expected_results, indices_rank, batch_dims, format::bfyx, { 36, 1, 1, 1 });
@ -236,33 +236,33 @@ TEST(gather_nd_gpu_fp16, d23223_i2321_ir4_batch3) {
// expected output dim: v5{12,3} v8{2,3,3,2}
set_values(input0, {
FLOAT16(11), FLOAT16(12), FLOAT16(13), FLOAT16(14), FLOAT16(15), FLOAT16(16), FLOAT16(17), FLOAT16(18),FLOAT16(15), FLOAT16(16), FLOAT16(17), FLOAT16(18),
FLOAT16(21), FLOAT16(22), FLOAT16(23), FLOAT16(24), FLOAT16(25), FLOAT16(26), FLOAT16(27), FLOAT16(28),FLOAT16(25), FLOAT16(26), FLOAT16(27), FLOAT16(28),
FLOAT16(29), FLOAT16(30), FLOAT16(31), FLOAT16(32), FLOAT16(33), FLOAT16(34), FLOAT16(35), FLOAT16(36),FLOAT16(33), FLOAT16(34), FLOAT16(35), FLOAT16(36),
ov::float16(11), ov::float16(12), ov::float16(13), ov::float16(14), ov::float16(15), ov::float16(16), ov::float16(17), ov::float16(18),ov::float16(15), ov::float16(16), ov::float16(17), ov::float16(18),
ov::float16(21), ov::float16(22), ov::float16(23), ov::float16(24), ov::float16(25), ov::float16(26), ov::float16(27), ov::float16(28),ov::float16(25), ov::float16(26), ov::float16(27), ov::float16(28),
ov::float16(29), ov::float16(30), ov::float16(31), ov::float16(32), ov::float16(33), ov::float16(34), ov::float16(35), ov::float16(36),ov::float16(33), ov::float16(34), ov::float16(35), ov::float16(36),
FLOAT16(11), FLOAT16(12), FLOAT16(13), FLOAT16(14), FLOAT16(15), FLOAT16(16), FLOAT16(17), FLOAT16(18),FLOAT16(15), FLOAT16(16), FLOAT16(17), FLOAT16(18),
FLOAT16(21), FLOAT16(22), FLOAT16(23), FLOAT16(24), FLOAT16(25), FLOAT16(26), FLOAT16(27), FLOAT16(28),FLOAT16(25), FLOAT16(26), FLOAT16(27), FLOAT16(28),
FLOAT16(29), FLOAT16(30), FLOAT16(31), FLOAT16(32), FLOAT16(33), FLOAT16(34), FLOAT16(35), FLOAT16(36),FLOAT16(33), FLOAT16(34), FLOAT16(35), FLOAT16(36),
ov::float16(11), ov::float16(12), ov::float16(13), ov::float16(14), ov::float16(15), ov::float16(16), ov::float16(17), ov::float16(18),ov::float16(15), ov::float16(16), ov::float16(17), ov::float16(18),
ov::float16(21), ov::float16(22), ov::float16(23), ov::float16(24), ov::float16(25), ov::float16(26), ov::float16(27), ov::float16(28),ov::float16(25), ov::float16(26), ov::float16(27), ov::float16(28),
ov::float16(29), ov::float16(30), ov::float16(31), ov::float16(32), ov::float16(33), ov::float16(34), ov::float16(35), ov::float16(36),ov::float16(33), ov::float16(34), ov::float16(35), ov::float16(36),
});
set_values(input1, {
FLOAT16(1), FLOAT16(1),
FLOAT16(1), FLOAT16(0),
FLOAT16(1), FLOAT16(1),
ov::float16(1), ov::float16(1),
ov::float16(1), ov::float16(0),
ov::float16(1), ov::float16(1),
FLOAT16(0), FLOAT16(0),
FLOAT16(0), FLOAT16(1),
FLOAT16(0), FLOAT16(0),
ov::float16(0), ov::float16(0),
ov::float16(0), ov::float16(1),
ov::float16(0), ov::float16(0),
});
std::vector<float> expected_results = {
FLOAT16(14), FLOAT16(15), FLOAT16(16), FLOAT16(16), FLOAT16(17), FLOAT16(18),
FLOAT16(24), FLOAT16(25), FLOAT16(26), FLOAT16(27), FLOAT16(28), FLOAT16(25),
FLOAT16(32), FLOAT16(33), FLOAT16(34), FLOAT16(34), FLOAT16(35), FLOAT16(36),
ov::float16(14), ov::float16(15), ov::float16(16), ov::float16(16), ov::float16(17), ov::float16(18),
ov::float16(24), ov::float16(25), ov::float16(26), ov::float16(27), ov::float16(28), ov::float16(25),
ov::float16(32), ov::float16(33), ov::float16(34), ov::float16(34), ov::float16(35), ov::float16(36),
FLOAT16(11), FLOAT16(12), FLOAT16(13), FLOAT16(17), FLOAT16(18), FLOAT16(15),
FLOAT16(21), FLOAT16(22), FLOAT16(23), FLOAT16(26), FLOAT16(27), FLOAT16(28),
FLOAT16(29), FLOAT16(30), FLOAT16(31), FLOAT16(35), FLOAT16(36), FLOAT16(33),
ov::float16(11), ov::float16(12), ov::float16(13), ov::float16(17), ov::float16(18), ov::float16(15),
ov::float16(21), ov::float16(22), ov::float16(23), ov::float16(26), ov::float16(27), ov::float16(28),
ov::float16(29), ov::float16(30), ov::float16(31), ov::float16(35), ov::float16(36), ov::float16(33),
};
DoTestV5(engine, input0, input1, expected_results, indices_rank, batch_dims, format::bfyx, { 12, 3, 1, 1 });
@ -279,33 +279,33 @@ TEST(gather_nd_gpu_fp16, d2342_i2312_ir4_batch2) {
// expected output dim: v5{6,1}, v8(2,3,1)
set_values(input0, {
FLOAT16(11), FLOAT16(12), FLOAT16(13), FLOAT16(14), FLOAT16(15), FLOAT16(16), FLOAT16(17), FLOAT16(18),
FLOAT16(21), FLOAT16(22), FLOAT16(23), FLOAT16(24), FLOAT16(25), FLOAT16(26), FLOAT16(27), FLOAT16(28),
FLOAT16(29), FLOAT16(30), FLOAT16(31), FLOAT16(32), FLOAT16(33), FLOAT16(34), FLOAT16(35), FLOAT16(36),
ov::float16(11), ov::float16(12), ov::float16(13), ov::float16(14), ov::float16(15), ov::float16(16), ov::float16(17), ov::float16(18),
ov::float16(21), ov::float16(22), ov::float16(23), ov::float16(24), ov::float16(25), ov::float16(26), ov::float16(27), ov::float16(28),
ov::float16(29), ov::float16(30), ov::float16(31), ov::float16(32), ov::float16(33), ov::float16(34), ov::float16(35), ov::float16(36),
FLOAT16(11), FLOAT16(12), FLOAT16(13), FLOAT16(14), FLOAT16(15), FLOAT16(16), FLOAT16(17), FLOAT16(18),
FLOAT16(21), FLOAT16(22), FLOAT16(23), FLOAT16(24), FLOAT16(25), FLOAT16(26), FLOAT16(27), FLOAT16(28),
FLOAT16(29), FLOAT16(30), FLOAT16(31), FLOAT16(32), FLOAT16(33), FLOAT16(34), FLOAT16(35), FLOAT16(36),
ov::float16(11), ov::float16(12), ov::float16(13), ov::float16(14), ov::float16(15), ov::float16(16), ov::float16(17), ov::float16(18),
ov::float16(21), ov::float16(22), ov::float16(23), ov::float16(24), ov::float16(25), ov::float16(26), ov::float16(27), ov::float16(28),
ov::float16(29), ov::float16(30), ov::float16(31), ov::float16(32), ov::float16(33), ov::float16(34), ov::float16(35), ov::float16(36),
});
set_values(input1, {
FLOAT16(1), FLOAT16(1),
FLOAT16(0), FLOAT16(0),
FLOAT16(2), FLOAT16(1),
ov::float16(1), ov::float16(1),
ov::float16(0), ov::float16(0),
ov::float16(2), ov::float16(1),
FLOAT16(0), FLOAT16(0),
FLOAT16(2), FLOAT16(1),
FLOAT16(2), FLOAT16(0),
ov::float16(0), ov::float16(0),
ov::float16(2), ov::float16(1),
ov::float16(2), ov::float16(0),
});
std::vector<float> expected_results = {
FLOAT16(14),
FLOAT16(21),
FLOAT16(34),
ov::float16(14),
ov::float16(21),
ov::float16(34),
FLOAT16(11),
FLOAT16(26),
FLOAT16(33),
ov::float16(11),
ov::float16(26),
ov::float16(33),
};
DoTestV5(engine, input0, input1, expected_results, indices_rank, batch_dims, format::bfyx, { 6, 1, 1, 1 });
@ -322,34 +322,34 @@ TEST(gather_nd_gpu_fp16, d234_i2311_ir4_batch2) {
// expected output dim: v5{6,1,1}, v8{2,3,1,1}
set_values(input0, {
FLOAT16(1), FLOAT16(2), FLOAT16(3), FLOAT16(4),
FLOAT16(5), FLOAT16(6), FLOAT16(7), FLOAT16(8),
FLOAT16(9), FLOAT16(10), FLOAT16(11), FLOAT16(12),
ov::float16(1), ov::float16(2), ov::float16(3), ov::float16(4),
ov::float16(5), ov::float16(6), ov::float16(7), ov::float16(8),
ov::float16(9), ov::float16(10), ov::float16(11), ov::float16(12),
FLOAT16(13), FLOAT16(14), FLOAT16(15), FLOAT16(16),
FLOAT16(17), FLOAT16(18), FLOAT16(19), FLOAT16(20),
FLOAT16(21), FLOAT16(22), FLOAT16(23), FLOAT16(24),
ov::float16(13), ov::float16(14), ov::float16(15), ov::float16(16),
ov::float16(17), ov::float16(18), ov::float16(19), ov::float16(20),
ov::float16(21), ov::float16(22), ov::float16(23), ov::float16(24),
});
set_values(input1, {
FLOAT16(1),
FLOAT16(0),
FLOAT16(2),
ov::float16(1),
ov::float16(0),
ov::float16(2),
FLOAT16(0),
FLOAT16(2),
FLOAT16(2),
ov::float16(0),
ov::float16(2),
ov::float16(2),
});
std::vector<float> expected_results = {
FLOAT16(2),
FLOAT16(5),
FLOAT16(11),
ov::float16(2),
ov::float16(5),
ov::float16(11),
FLOAT16(13),
FLOAT16(19),
FLOAT16(23),
ov::float16(13),
ov::float16(19),
ov::float16(23),
};
DoTestV5(engine, input0, input1, expected_results, indices_rank, batch_dims, format::bfyx, { 6, 1, 1, 1 });
@ -366,24 +366,24 @@ TEST(gather_nd_gpu_fp16, d234_i21_ir2_batch1) {
// expected output dim: v5{2,4,1,1}, v8{2,4,1,1}
set_values(input0, {
FLOAT16(1), FLOAT16(2), FLOAT16(3), FLOAT16(4),
FLOAT16(5), FLOAT16(6), FLOAT16(7), FLOAT16(8),
FLOAT16(9), FLOAT16(10), FLOAT16(11), FLOAT16(12),
ov::float16(1), ov::float16(2), ov::float16(3), ov::float16(4),
ov::float16(5), ov::float16(6), ov::float16(7), ov::float16(8),
ov::float16(9), ov::float16(10), ov::float16(11), ov::float16(12),
FLOAT16(13), FLOAT16(14), FLOAT16(15), FLOAT16(16),
FLOAT16(17), FLOAT16(18), FLOAT16(19), FLOAT16(20),
FLOAT16(21), FLOAT16(22), FLOAT16(23), FLOAT16(24),
ov::float16(13), ov::float16(14), ov::float16(15), ov::float16(16),
ov::float16(17), ov::float16(18), ov::float16(19), ov::float16(20),
ov::float16(21), ov::float16(22), ov::float16(23), ov::float16(24),
});
set_values(input1, {
FLOAT16(1),
FLOAT16(0),
ov::float16(1),
ov::float16(0),
});
std::vector<float> expected_results = {
FLOAT16(5), FLOAT16(6), FLOAT16(7), FLOAT16(8),
FLOAT16(13), FLOAT16(14), FLOAT16(15), FLOAT16(16),
ov::float16(5), ov::float16(6), ov::float16(7), ov::float16(8),
ov::float16(13), ov::float16(14), ov::float16(15), ov::float16(16),
};
DoTestV5(engine, input0, input1, expected_results, indices_rank, batch_dims, format::bfyx, { 2, 4, 1, 1 });
@ -400,18 +400,18 @@ TEST(gather_nd_gpu_fp16, d22_i21_ir2_batch1) {
// expected output dim: v5{2,1,1}, v8{2,1,1}
set_values(input0, {
FLOAT16(1), FLOAT16(2),
FLOAT16(3), FLOAT16(4),
ov::float16(1), ov::float16(2),
ov::float16(3), ov::float16(4),
});
set_values(input1, {
FLOAT16(1),
FLOAT16(0),
ov::float16(1),
ov::float16(0),
});
std::vector<float> expected_results = {
FLOAT16(2),
FLOAT16(3),
ov::float16(2),
ov::float16(3),
};
DoTestV5(engine, input0, input1, expected_results, indices_rank, batch_dims, format::bfyx, { 2, 1, 1, 1 });
@ -428,36 +428,36 @@ TEST(gather_nd_gpu_fp16, d3223_i321113_ir6_batch0) {
// expected output dim: 323111
set_values(input0, {
FLOAT16(11), FLOAT16(12), FLOAT16(13), FLOAT16(14), FLOAT16(15), FLOAT16(16),
FLOAT16(21), FLOAT16(22), FLOAT16(23), FLOAT16(24), FLOAT16(25), FLOAT16(26),
ov::float16(11), ov::float16(12), ov::float16(13), ov::float16(14), ov::float16(15), ov::float16(16),
ov::float16(21), ov::float16(22), ov::float16(23), ov::float16(24), ov::float16(25), ov::float16(26),
FLOAT16(31), FLOAT16(32), FLOAT16(33), FLOAT16(34), FLOAT16(35), FLOAT16(36),
FLOAT16(41), FLOAT16(42), FLOAT16(43), FLOAT16(44), FLOAT16(45), FLOAT16(46),
ov::float16(31), ov::float16(32), ov::float16(33), ov::float16(34), ov::float16(35), ov::float16(36),
ov::float16(41), ov::float16(42), ov::float16(43), ov::float16(44), ov::float16(45), ov::float16(46),
FLOAT16(51), FLOAT16(52), FLOAT16(53), FLOAT16(54), FLOAT16(55), FLOAT16(56),
FLOAT16(61), FLOAT16(62), FLOAT16(63), FLOAT16(64), FLOAT16(65), FLOAT16(66),
ov::float16(51), ov::float16(52), ov::float16(53), ov::float16(54), ov::float16(55), ov::float16(56),
ov::float16(61), ov::float16(62), ov::float16(63), ov::float16(64), ov::float16(65), ov::float16(66),
});
set_values(input1, {
FLOAT16(2), FLOAT16(1), FLOAT16(1),
FLOAT16(1), FLOAT16(0), FLOAT16(0),
ov::float16(2), ov::float16(1), ov::float16(1),
ov::float16(1), ov::float16(0), ov::float16(0),
FLOAT16(0), FLOAT16(1), FLOAT16(0),
FLOAT16(2), FLOAT16(0), FLOAT16(1),
ov::float16(0), ov::float16(1), ov::float16(0),
ov::float16(2), ov::float16(0), ov::float16(1),
FLOAT16(1), FLOAT16(1), FLOAT16(0),
FLOAT16(0), FLOAT16(0), FLOAT16(0),
ov::float16(1), ov::float16(1), ov::float16(0),
ov::float16(0), ov::float16(0), ov::float16(0),
});
std::vector<float> expected_results = {
FLOAT16(64), FLOAT16(65), FLOAT16(66),
FLOAT16(31), FLOAT16(32), FLOAT16(33),
ov::float16(64), ov::float16(65), ov::float16(66),
ov::float16(31), ov::float16(32), ov::float16(33),
FLOAT16(21), FLOAT16(22), FLOAT16(23),
FLOAT16(54), FLOAT16(55), FLOAT16(56),
ov::float16(21), ov::float16(22), ov::float16(23),
ov::float16(54), ov::float16(55), ov::float16(56),
FLOAT16(41), FLOAT16(42), FLOAT16(43),
FLOAT16(11), FLOAT16(12), FLOAT16(13),
ov::float16(41), ov::float16(42), ov::float16(43),
ov::float16(11), ov::float16(12), ov::float16(13),
};
DoTestV5(engine, input0, input1, expected_results, indices_rank, batch_dims, format::bfwzyx, { 3, 2, 3, 1, 1, 1 });
@ -474,36 +474,36 @@ TEST(gather_nd_gpu_fp16, d3221_i32312_ir3_batch0) {
// expected output dim: 32213
set_values(input0, {
FLOAT16(11), FLOAT16(12), FLOAT16(13), FLOAT16(14), FLOAT16(15), FLOAT16(16),
FLOAT16(21), FLOAT16(22), FLOAT16(23), FLOAT16(24), FLOAT16(25), FLOAT16(26),
ov::float16(11), ov::float16(12), ov::float16(13), ov::float16(14), ov::float16(15), ov::float16(16),
ov::float16(21), ov::float16(22), ov::float16(23), ov::float16(24), ov::float16(25), ov::float16(26),
FLOAT16(31), FLOAT16(32), FLOAT16(33), FLOAT16(34), FLOAT16(35), FLOAT16(36),
FLOAT16(41), FLOAT16(42), FLOAT16(43), FLOAT16(44), FLOAT16(45), FLOAT16(46),
ov::float16(31), ov::float16(32), ov::float16(33), ov::float16(34), ov::float16(35), ov::float16(36),
ov::float16(41), ov::float16(42), ov::float16(43), ov::float16(44), ov::float16(45), ov::float16(46),
FLOAT16(51), FLOAT16(52), FLOAT16(53), FLOAT16(54), FLOAT16(55), FLOAT16(56),
FLOAT16(61), FLOAT16(62), FLOAT16(63), FLOAT16(64), FLOAT16(65), FLOAT16(66),
ov::float16(51), ov::float16(52), ov::float16(53), ov::float16(54), ov::float16(55), ov::float16(56),
ov::float16(61), ov::float16(62), ov::float16(63), ov::float16(64), ov::float16(65), ov::float16(66),
});
set_values(input1, {
FLOAT16(2), FLOAT16(1),
FLOAT16(1), FLOAT16(0),
ov::float16(2), ov::float16(1),
ov::float16(1), ov::float16(0),
FLOAT16(0), FLOAT16(1),
FLOAT16(2), FLOAT16(0),
ov::float16(0), ov::float16(1),
ov::float16(2), ov::float16(0),
FLOAT16(1), FLOAT16(1),
FLOAT16(0), FLOAT16(0),
ov::float16(1), ov::float16(1),
ov::float16(0), ov::float16(0),
});
std::vector<float> expected_results = {
FLOAT16(61), FLOAT16(62), FLOAT16(63), FLOAT16(64), FLOAT16(65), FLOAT16(66),
FLOAT16(31), FLOAT16(32), FLOAT16(33), FLOAT16(34), FLOAT16(35), FLOAT16(36),
ov::float16(61), ov::float16(62), ov::float16(63), ov::float16(64), ov::float16(65), ov::float16(66),
ov::float16(31), ov::float16(32), ov::float16(33), ov::float16(34), ov::float16(35), ov::float16(36),
FLOAT16(21), FLOAT16(22), FLOAT16(23), FLOAT16(24), FLOAT16(25), FLOAT16(26),
FLOAT16(51), FLOAT16(52), FLOAT16(53), FLOAT16(54), FLOAT16(55), FLOAT16(56),
ov::float16(21), ov::float16(22), ov::float16(23), ov::float16(24), ov::float16(25), ov::float16(26),
ov::float16(51), ov::float16(52), ov::float16(53), ov::float16(54), ov::float16(55), ov::float16(56),
FLOAT16(41), FLOAT16(42), FLOAT16(43), FLOAT16(44), FLOAT16(45), FLOAT16(46),
FLOAT16(11), FLOAT16(12), FLOAT16(13), FLOAT16(14), FLOAT16(15), FLOAT16(16),
ov::float16(41), ov::float16(42), ov::float16(43), ov::float16(44), ov::float16(45), ov::float16(46),
ov::float16(11), ov::float16(12), ov::float16(13), ov::float16(14), ov::float16(15), ov::float16(16),
};
DoTestV5(engine, input0, input1, expected_results, indices_rank, batch_dims, format::bfzyx, { 3, 2, 2, 1, 3 });
@ -520,36 +520,36 @@ TEST(gather_nd_gpu_fp16, d3231_i32312_ir3_batch0) {
// expected output dim: {3,2,2,1}
set_values(input0, {
FLOAT16(11), FLOAT16(12), FLOAT16(13), FLOAT16(14), FLOAT16(15), FLOAT16(16),
FLOAT16(21), FLOAT16(22), FLOAT16(23), FLOAT16(24), FLOAT16(25), FLOAT16(26),
ov::float16(11), ov::float16(12), ov::float16(13), ov::float16(14), ov::float16(15), ov::float16(16),
ov::float16(21), ov::float16(22), ov::float16(23), ov::float16(24), ov::float16(25), ov::float16(26),
FLOAT16(31), FLOAT16(32), FLOAT16(33), FLOAT16(34), FLOAT16(35), FLOAT16(36),
FLOAT16(41), FLOAT16(42), FLOAT16(43), FLOAT16(44), FLOAT16(45), FLOAT16(46),
ov::float16(31), ov::float16(32), ov::float16(33), ov::float16(34), ov::float16(35), ov::float16(36),
ov::float16(41), ov::float16(42), ov::float16(43), ov::float16(44), ov::float16(45), ov::float16(46),
FLOAT16(51), FLOAT16(52), FLOAT16(53), FLOAT16(54), FLOAT16(55), FLOAT16(56),
FLOAT16(61), FLOAT16(62), FLOAT16(63), FLOAT16(64), FLOAT16(65), FLOAT16(66),
ov::float16(51), ov::float16(52), ov::float16(53), ov::float16(54), ov::float16(55), ov::float16(56),
ov::float16(61), ov::float16(62), ov::float16(63), ov::float16(64), ov::float16(65), ov::float16(66),
});
set_values(input1, {
FLOAT16(2), FLOAT16(1), FLOAT16(1),
FLOAT16(1), FLOAT16(0), FLOAT16(2),
ov::float16(2), ov::float16(1), ov::float16(1),
ov::float16(1), ov::float16(0), ov::float16(2),
FLOAT16(0), FLOAT16(1), FLOAT16(0),
FLOAT16(2), FLOAT16(0), FLOAT16(1),
ov::float16(0), ov::float16(1), ov::float16(0),
ov::float16(2), ov::float16(0), ov::float16(1),
FLOAT16(1), FLOAT16(1), FLOAT16(2),
FLOAT16(0), FLOAT16(0), FLOAT16(0),
ov::float16(1), ov::float16(1), ov::float16(2),
ov::float16(0), ov::float16(0), ov::float16(0),
});
std::vector<float> expected_results = {
FLOAT16(63), FLOAT16(64),
FLOAT16(35), FLOAT16(36),
ov::float16(63), ov::float16(64),
ov::float16(35), ov::float16(36),
FLOAT16(21), FLOAT16(22),
FLOAT16(53), FLOAT16(54),
ov::float16(21), ov::float16(22),
ov::float16(53), ov::float16(54),
FLOAT16(45), FLOAT16(46),
FLOAT16(11), FLOAT16(12),
ov::float16(45), ov::float16(46),
ov::float16(11), ov::float16(12),
};
DoTestV5(engine, input0, input1, expected_results, indices_rank, batch_dims, format::bfyx, { 3, 2, 2, 1 });
@ -566,31 +566,31 @@ TEST(gather_nd_gpu_fp16, d3112_i3221_ir4_batch0) {
// expected output dim: {3,2,2,1,1,2}
set_values(input0, {
FLOAT16(1), FLOAT16(2),
FLOAT16(7), FLOAT16(8),
FLOAT16(13), FLOAT16(14),
ov::float16(1), ov::float16(2),
ov::float16(7), ov::float16(8),
ov::float16(13), ov::float16(14),
});
set_values(input1, {
FLOAT16(2), FLOAT16(1),
FLOAT16(0), FLOAT16(1),
ov::float16(2), ov::float16(1),
ov::float16(0), ov::float16(1),
FLOAT16(2), FLOAT16(1),
FLOAT16(0), FLOAT16(1),
ov::float16(2), ov::float16(1),
ov::float16(0), ov::float16(1),
FLOAT16(2), FLOAT16(1),
FLOAT16(0), FLOAT16(1),
ov::float16(2), ov::float16(1),
ov::float16(0), ov::float16(1),
});
std::vector<float> expected_results = {
FLOAT16(13), FLOAT16(14), FLOAT16(7), FLOAT16(8),
FLOAT16(1), FLOAT16(2), FLOAT16(7), FLOAT16(8),
ov::float16(13), ov::float16(14), ov::float16(7), ov::float16(8),
ov::float16(1), ov::float16(2), ov::float16(7), ov::float16(8),
FLOAT16(13), FLOAT16(14), FLOAT16(7), FLOAT16(8),
FLOAT16(1), FLOAT16(2), FLOAT16(7), FLOAT16(8),
ov::float16(13), ov::float16(14), ov::float16(7), ov::float16(8),
ov::float16(1), ov::float16(2), ov::float16(7), ov::float16(8),
FLOAT16(13), FLOAT16(14), FLOAT16(7), FLOAT16(8),
FLOAT16(1), FLOAT16(2), FLOAT16(7), FLOAT16(8),
ov::float16(13), ov::float16(14), ov::float16(7), ov::float16(8),
ov::float16(1), ov::float16(2), ov::float16(7), ov::float16(8),
};
DoTestV5(engine, input0, input1, expected_results, indices_rank, batch_dims, format::bfwzyx, { 3, 2, 2, 1, 1, 2 });
@ -607,39 +607,39 @@ TEST(gather_nd_gpu_fp16, d3332_i3223_ir4_batch0) {
// expected output dim: {3,2,3,2}
set_values(input0, {
FLOAT16(1), FLOAT16(2), FLOAT16(3), FLOAT16(4), FLOAT16(5), FLOAT16(6),
FLOAT16(7), FLOAT16(8), FLOAT16(9), FLOAT16(10), FLOAT16(11), FLOAT16(12),
FLOAT16(13), FLOAT16(14), FLOAT16(15), FLOAT16(16), FLOAT16(17), FLOAT16(18),
ov::float16(1), ov::float16(2), ov::float16(3), ov::float16(4), ov::float16(5), ov::float16(6),
ov::float16(7), ov::float16(8), ov::float16(9), ov::float16(10), ov::float16(11), ov::float16(12),
ov::float16(13), ov::float16(14), ov::float16(15), ov::float16(16), ov::float16(17), ov::float16(18),
FLOAT16(19), FLOAT16(20), FLOAT16(21), FLOAT16(22), FLOAT16(23), FLOAT16(24),
FLOAT16(25), FLOAT16(26), FLOAT16(27), FLOAT16(28), FLOAT16(29), FLOAT16(30),
FLOAT16(31), FLOAT16(32), FLOAT16(33), FLOAT16(34), FLOAT16(35), FLOAT16(36),
ov::float16(19), ov::float16(20), ov::float16(21), ov::float16(22), ov::float16(23), ov::float16(24),
ov::float16(25), ov::float16(26), ov::float16(27), ov::float16(28), ov::float16(29), ov::float16(30),
ov::float16(31), ov::float16(32), ov::float16(33), ov::float16(34), ov::float16(35), ov::float16(36),
FLOAT16(41), FLOAT16(42), FLOAT16(43), FLOAT16(44), FLOAT16(45), FLOAT16(46),
FLOAT16(51), FLOAT16(52), FLOAT16(53), FLOAT16(54), FLOAT16(55), FLOAT16(56),
FLOAT16(61), FLOAT16(62), FLOAT16(63), FLOAT16(64), FLOAT16(65), FLOAT16(66),
ov::float16(41), ov::float16(42), ov::float16(43), ov::float16(44), ov::float16(45), ov::float16(46),
ov::float16(51), ov::float16(52), ov::float16(53), ov::float16(54), ov::float16(55), ov::float16(56),
ov::float16(61), ov::float16(62), ov::float16(63), ov::float16(64), ov::float16(65), ov::float16(66),
});
set_values(input1, {
FLOAT16(2), FLOAT16(0), FLOAT16(0), FLOAT16(2), FLOAT16(2), FLOAT16(0),
FLOAT16(1), FLOAT16(0), FLOAT16(0), FLOAT16(1), FLOAT16(1), FLOAT16(0),
ov::float16(2), ov::float16(0), ov::float16(0), ov::float16(2), ov::float16(2), ov::float16(0),
ov::float16(1), ov::float16(0), ov::float16(0), ov::float16(1), ov::float16(1), ov::float16(0),
FLOAT16(1), FLOAT16(0), FLOAT16(1), FLOAT16(1), FLOAT16(1), FLOAT16(1),
FLOAT16(2), FLOAT16(0), FLOAT16(0), FLOAT16(2), FLOAT16(1), FLOAT16(0),
ov::float16(1), ov::float16(0), ov::float16(1), ov::float16(1), ov::float16(1), ov::float16(1),
ov::float16(2), ov::float16(0), ov::float16(0), ov::float16(2), ov::float16(1), ov::float16(0),
FLOAT16(1), FLOAT16(1), FLOAT16(1), FLOAT16(0), FLOAT16(1), FLOAT16(1),
FLOAT16(1), FLOAT16(2), FLOAT16(1), FLOAT16(0), FLOAT16(2), FLOAT16(1),
ov::float16(1), ov::float16(1), ov::float16(1), ov::float16(0), ov::float16(1), ov::float16(1),
ov::float16(1), ov::float16(2), ov::float16(1), ov::float16(0), ov::float16(2), ov::float16(1),
});
std::vector<float> expected_results = {
FLOAT16(41), FLOAT16(42), FLOAT16(43), FLOAT16(61), FLOAT16(62), FLOAT16(63),
FLOAT16(19), FLOAT16(20), FLOAT16(21), FLOAT16(25), FLOAT16(26), FLOAT16(27),
ov::float16(41), ov::float16(42), ov::float16(43), ov::float16(61), ov::float16(62), ov::float16(63),
ov::float16(19), ov::float16(20), ov::float16(21), ov::float16(25), ov::float16(26), ov::float16(27),
FLOAT16(22), FLOAT16(23), FLOAT16(24), FLOAT16(28), FLOAT16(29), FLOAT16(30),
FLOAT16(41), FLOAT16(42), FLOAT16(43), FLOAT16(51), FLOAT16(52), FLOAT16(53),
ov::float16(22), ov::float16(23), ov::float16(24), ov::float16(28), ov::float16(29), ov::float16(30),
ov::float16(41), ov::float16(42), ov::float16(43), ov::float16(51), ov::float16(52), ov::float16(53),
FLOAT16(28), FLOAT16(29), FLOAT16(30), FLOAT16(10), FLOAT16(11), FLOAT16(12),
FLOAT16(34), FLOAT16(35), FLOAT16(36), FLOAT16(16), FLOAT16(17), FLOAT16(18),
ov::float16(28), ov::float16(29), ov::float16(30), ov::float16(10), ov::float16(11), ov::float16(12),
ov::float16(34), ov::float16(35), ov::float16(36), ov::float16(16), ov::float16(17), ov::float16(18),
};
DoTestV5(engine, input0, input1, expected_results, indices_rank, batch_dims, format::bfyx, { 3, 2, 3, 2 });
@ -656,39 +656,39 @@ TEST(gather_nd_gpu_fp16, d3323_i322_ir3_batch0) {
// expected output dim: {3,2,3,2}
set_values(input0, {
FLOAT16(1), FLOAT16(2), FLOAT16(3), FLOAT16(4), FLOAT16(5), FLOAT16(6),
FLOAT16(7), FLOAT16(8), FLOAT16(9), FLOAT16(10), FLOAT16(11), FLOAT16(12),
FLOAT16(13), FLOAT16(14), FLOAT16(15), FLOAT16(16), FLOAT16(17), FLOAT16(18),
ov::float16(1), ov::float16(2), ov::float16(3), ov::float16(4), ov::float16(5), ov::float16(6),
ov::float16(7), ov::float16(8), ov::float16(9), ov::float16(10), ov::float16(11), ov::float16(12),
ov::float16(13), ov::float16(14), ov::float16(15), ov::float16(16), ov::float16(17), ov::float16(18),
FLOAT16(19), FLOAT16(20), FLOAT16(21), FLOAT16(22), FLOAT16(23), FLOAT16(24),
FLOAT16(25), FLOAT16(26), FLOAT16(27), FLOAT16(28), FLOAT16(29), FLOAT16(30),
FLOAT16(31), FLOAT16(32), FLOAT16(33), FLOAT16(34), FLOAT16(35), FLOAT16(36),
ov::float16(19), ov::float16(20), ov::float16(21), ov::float16(22), ov::float16(23), ov::float16(24),
ov::float16(25), ov::float16(26), ov::float16(27), ov::float16(28), ov::float16(29), ov::float16(30),
ov::float16(31), ov::float16(32), ov::float16(33), ov::float16(34), ov::float16(35), ov::float16(36),
FLOAT16(41), FLOAT16(42), FLOAT16(43), FLOAT16(44), FLOAT16(45), FLOAT16(46),
FLOAT16(51), FLOAT16(52), FLOAT16(53), FLOAT16(54), FLOAT16(55), FLOAT16(56),
FLOAT16(61), FLOAT16(62), FLOAT16(63), FLOAT16(64), FLOAT16(65), FLOAT16(66),
ov::float16(41), ov::float16(42), ov::float16(43), ov::float16(44), ov::float16(45), ov::float16(46),
ov::float16(51), ov::float16(52), ov::float16(53), ov::float16(54), ov::float16(55), ov::float16(56),
ov::float16(61), ov::float16(62), ov::float16(63), ov::float16(64), ov::float16(65), ov::float16(66),
});
set_values(input1, {
FLOAT16(2), FLOAT16(0),
FLOAT16(2), FLOAT16(1),
ov::float16(2), ov::float16(0),
ov::float16(2), ov::float16(1),
FLOAT16(1), FLOAT16(2),
FLOAT16(1), FLOAT16(0),
ov::float16(1), ov::float16(2),
ov::float16(1), ov::float16(0),
FLOAT16(0), FLOAT16(1),
FLOAT16(0), FLOAT16(2),
ov::float16(0), ov::float16(1),
ov::float16(0), ov::float16(2),
});
std::vector<float> expected_results = {
FLOAT16(41), FLOAT16(42), FLOAT16(43), FLOAT16(44), FLOAT16(45), FLOAT16(46),
FLOAT16(51), FLOAT16(52), FLOAT16(53), FLOAT16(54), FLOAT16(55), FLOAT16(56),
ov::float16(41), ov::float16(42), ov::float16(43), ov::float16(44), ov::float16(45), ov::float16(46),
ov::float16(51), ov::float16(52), ov::float16(53), ov::float16(54), ov::float16(55), ov::float16(56),
FLOAT16(31), FLOAT16(32), FLOAT16(33), FLOAT16(34), FLOAT16(35), FLOAT16(36),
FLOAT16(19), FLOAT16(20), FLOAT16(21), FLOAT16(22), FLOAT16(23), FLOAT16(24),
ov::float16(31), ov::float16(32), ov::float16(33), ov::float16(34), ov::float16(35), ov::float16(36),
ov::float16(19), ov::float16(20), ov::float16(21), ov::float16(22), ov::float16(23), ov::float16(24),
FLOAT16(7), FLOAT16(8), FLOAT16(9), FLOAT16(10), FLOAT16(11), FLOAT16(12),
FLOAT16(13), FLOAT16(14), FLOAT16(15), FLOAT16(16), FLOAT16(17), FLOAT16(18),
ov::float16(7), ov::float16(8), ov::float16(9), ov::float16(10), ov::float16(11), ov::float16(12),
ov::float16(13), ov::float16(14), ov::float16(15), ov::float16(16), ov::float16(17), ov::float16(18),
};
DoTestV5(engine, input0, input1, expected_results, indices_rank, batch_dims, format::bfyx, { 3, 2, 3, 2 });
@ -705,17 +705,17 @@ TEST(gather_nd_gpu_fp16, d22_i21_ir2_batch0) {
// expected output dim: {2,2,1,1}
set_values(input0, {
FLOAT16(1), FLOAT16(2),
FLOAT16(3), FLOAT16(4)
ov::float16(1), ov::float16(2),
ov::float16(3), ov::float16(4)
});
set_values(input1, {
FLOAT16(1), FLOAT16(0),
ov::float16(1), ov::float16(0),
});
std::vector<float> expected_results = {
FLOAT16(3), FLOAT16(4),
FLOAT16(1), FLOAT16(2),
ov::float16(3), ov::float16(4),
ov::float16(1), ov::float16(2),
};
DoTestV5(engine, input0, input1, expected_results, indices_rank, batch_dims, format::bfyx, { 2, 2, 1, 1 });
@ -732,20 +732,20 @@ TEST(gather_nd_gpu_fp16, d22_i32_ir2_batch0) {
// expected output dim: {3,1,1}
set_values(input0, {
FLOAT16(1), FLOAT16(2),
FLOAT16(3), FLOAT16(4)
ov::float16(1), ov::float16(2),
ov::float16(3), ov::float16(4)
});
set_values(input1, {
FLOAT16(0), FLOAT16(0),
FLOAT16(1), FLOAT16(0),
FLOAT16(1), FLOAT16(1),
ov::float16(0), ov::float16(0),
ov::float16(1), ov::float16(0),
ov::float16(1), ov::float16(1),
});
std::vector<float> expected_results = {
FLOAT16(1),
FLOAT16(3),
FLOAT16(4),
ov::float16(1),
ov::float16(3),
ov::float16(4),
};
DoTestV5(engine,input0, input1, expected_results, indices_rank, batch_dims, format::bfyx, { 3, 1, 1, 1 });
@ -762,20 +762,20 @@ TEST(gather_nd_gpu_fp16, export_import) {
// expected output dim: {3,1,1}
set_values(input0, {
FLOAT16(1), FLOAT16(2),
FLOAT16(3), FLOAT16(4)
ov::float16(1), ov::float16(2),
ov::float16(3), ov::float16(4)
});
set_values(input1, {
FLOAT16(0), FLOAT16(0),
FLOAT16(1), FLOAT16(0),
FLOAT16(1), FLOAT16(1),
ov::float16(0), ov::float16(0),
ov::float16(1), ov::float16(0),
ov::float16(1), ov::float16(1),
});
std::vector<float> expected_results = {
FLOAT16(1),
FLOAT16(3),
FLOAT16(4),
ov::float16(1),
ov::float16(3),
ov::float16(4),
};
DoTestV5(engine,input0, input1, expected_results, indices_rank, batch_dims, format::bfyx, { 3, 1, 1, 1 }, true);
@ -794,39 +794,39 @@ TEST(gather_nd_gpu_fp16, dynamic_r4) {
auto input2 = engine.allocate_memory(layout{ov::PartialShape(in2_shape), data_types::f16, format::bfyx}); // Indexes
set_values(input1, {
FLOAT16(1), FLOAT16(2), FLOAT16(3), FLOAT16(4), FLOAT16(5), FLOAT16(6),
FLOAT16(7), FLOAT16(8), FLOAT16(9), FLOAT16(10), FLOAT16(11), FLOAT16(12),
FLOAT16(13), FLOAT16(14), FLOAT16(15), FLOAT16(16), FLOAT16(17), FLOAT16(18),
ov::float16(1), ov::float16(2), ov::float16(3), ov::float16(4), ov::float16(5), ov::float16(6),
ov::float16(7), ov::float16(8), ov::float16(9), ov::float16(10), ov::float16(11), ov::float16(12),
ov::float16(13), ov::float16(14), ov::float16(15), ov::float16(16), ov::float16(17), ov::float16(18),
FLOAT16(19), FLOAT16(20), FLOAT16(21), FLOAT16(22), FLOAT16(23), FLOAT16(24),
FLOAT16(25), FLOAT16(26), FLOAT16(27), FLOAT16(28), FLOAT16(29), FLOAT16(30),
FLOAT16(31), FLOAT16(32), FLOAT16(33), FLOAT16(34), FLOAT16(35), FLOAT16(36),
ov::float16(19), ov::float16(20), ov::float16(21), ov::float16(22), ov::float16(23), ov::float16(24),
ov::float16(25), ov::float16(26), ov::float16(27), ov::float16(28), ov::float16(29), ov::float16(30),
ov::float16(31), ov::float16(32), ov::float16(33), ov::float16(34), ov::float16(35), ov::float16(36),
FLOAT16(41), FLOAT16(42), FLOAT16(43), FLOAT16(44), FLOAT16(45), FLOAT16(46),
FLOAT16(51), FLOAT16(52), FLOAT16(53), FLOAT16(54), FLOAT16(55), FLOAT16(56),
FLOAT16(61), FLOAT16(62), FLOAT16(63), FLOAT16(64), FLOAT16(65), FLOAT16(66),
ov::float16(41), ov::float16(42), ov::float16(43), ov::float16(44), ov::float16(45), ov::float16(46),
ov::float16(51), ov::float16(52), ov::float16(53), ov::float16(54), ov::float16(55), ov::float16(56),
ov::float16(61), ov::float16(62), ov::float16(63), ov::float16(64), ov::float16(65), ov::float16(66),
});
set_values(input2, {
FLOAT16(2), FLOAT16(0), FLOAT16(0), FLOAT16(2), FLOAT16(2), FLOAT16(0),
FLOAT16(1), FLOAT16(0), FLOAT16(0), FLOAT16(1), FLOAT16(1), FLOAT16(0),
ov::float16(2), ov::float16(0), ov::float16(0), ov::float16(2), ov::float16(2), ov::float16(0),
ov::float16(1), ov::float16(0), ov::float16(0), ov::float16(1), ov::float16(1), ov::float16(0),
FLOAT16(1), FLOAT16(0), FLOAT16(1), FLOAT16(1), FLOAT16(1), FLOAT16(1),
FLOAT16(2), FLOAT16(0), FLOAT16(0), FLOAT16(2), FLOAT16(1), FLOAT16(0),
ov::float16(1), ov::float16(0), ov::float16(1), ov::float16(1), ov::float16(1), ov::float16(1),
ov::float16(2), ov::float16(0), ov::float16(0), ov::float16(2), ov::float16(1), ov::float16(0),
FLOAT16(1), FLOAT16(1), FLOAT16(1), FLOAT16(0), FLOAT16(1), FLOAT16(1),
FLOAT16(1), FLOAT16(2), FLOAT16(1), FLOAT16(0), FLOAT16(2), FLOAT16(1),
ov::float16(1), ov::float16(1), ov::float16(1), ov::float16(0), ov::float16(1), ov::float16(1),
ov::float16(1), ov::float16(2), ov::float16(1), ov::float16(0), ov::float16(2), ov::float16(1),
});
std::vector<float> expected_results = {
FLOAT16(41), FLOAT16(42), FLOAT16(43), FLOAT16(61), FLOAT16(62), FLOAT16(63),
FLOAT16(19), FLOAT16(20), FLOAT16(21), FLOAT16(25), FLOAT16(26), FLOAT16(27),
ov::float16(41), ov::float16(42), ov::float16(43), ov::float16(61), ov::float16(62), ov::float16(63),
ov::float16(19), ov::float16(20), ov::float16(21), ov::float16(25), ov::float16(26), ov::float16(27),
FLOAT16(22), FLOAT16(23), FLOAT16(24), FLOAT16(28), FLOAT16(29), FLOAT16(30),
FLOAT16(41), FLOAT16(42), FLOAT16(43), FLOAT16(51), FLOAT16(52), FLOAT16(53),
ov::float16(22), ov::float16(23), ov::float16(24), ov::float16(28), ov::float16(29), ov::float16(30),
ov::float16(41), ov::float16(42), ov::float16(43), ov::float16(51), ov::float16(52), ov::float16(53),
FLOAT16(28), FLOAT16(29), FLOAT16(30), FLOAT16(10), FLOAT16(11), FLOAT16(12),
FLOAT16(34), FLOAT16(35), FLOAT16(36), FLOAT16(16), FLOAT16(17), FLOAT16(18),
ov::float16(28), ov::float16(29), ov::float16(30), ov::float16(10), ov::float16(11), ov::float16(12),
ov::float16(34), ov::float16(35), ov::float16(36), ov::float16(16), ov::float16(17), ov::float16(18),
};
auto expected_fmt = format::bfyx;
@ -882,33 +882,33 @@ TEST(gather_nd_gpu_fp16, dynamic_r5) {
auto input2 = engine.allocate_memory(layout{ov::PartialShape(in2_shape), data_types::f16, format::bfzyx}); // Indexes
set_values(input1, {
FLOAT16(11), FLOAT16(12), FLOAT16(13), FLOAT16(14), FLOAT16(15), FLOAT16(16), FLOAT16(17), FLOAT16(18), FLOAT16(19), FLOAT16(10), FLOAT16(21), FLOAT16(18),
FLOAT16(21), FLOAT16(22), FLOAT16(23), FLOAT16(24), FLOAT16(25), FLOAT16(26), FLOAT16(27), FLOAT16(28), FLOAT16(29), FLOAT16(20), FLOAT16(27), FLOAT16(28),
FLOAT16(31), FLOAT16(32), FLOAT16(33), FLOAT16(34), FLOAT16(35), FLOAT16(36), FLOAT16(37), FLOAT16(38), FLOAT16(39), FLOAT16(30), FLOAT16(31), FLOAT16(30),
ov::float16(11), ov::float16(12), ov::float16(13), ov::float16(14), ov::float16(15), ov::float16(16), ov::float16(17), ov::float16(18), ov::float16(19), ov::float16(10), ov::float16(21), ov::float16(18),
ov::float16(21), ov::float16(22), ov::float16(23), ov::float16(24), ov::float16(25), ov::float16(26), ov::float16(27), ov::float16(28), ov::float16(29), ov::float16(20), ov::float16(27), ov::float16(28),
ov::float16(31), ov::float16(32), ov::float16(33), ov::float16(34), ov::float16(35), ov::float16(36), ov::float16(37), ov::float16(38), ov::float16(39), ov::float16(30), ov::float16(31), ov::float16(30),
FLOAT16(11), FLOAT16(12), FLOAT16(13), FLOAT16(14), FLOAT16(15), FLOAT16(16), FLOAT16(17), FLOAT16(18), FLOAT16(19), FLOAT16(10), FLOAT16(17), FLOAT16(18),
FLOAT16(21), FLOAT16(22), FLOAT16(23), FLOAT16(24), FLOAT16(25), FLOAT16(26), FLOAT16(27), FLOAT16(28), FLOAT16(29), FLOAT16(20), FLOAT16(27), FLOAT16(28),
FLOAT16(31), FLOAT16(32), FLOAT16(33), FLOAT16(34), FLOAT16(35), FLOAT16(36), FLOAT16(37), FLOAT16(38), FLOAT16(39), FLOAT16(30), FLOAT16(29), FLOAT16(30),
ov::float16(11), ov::float16(12), ov::float16(13), ov::float16(14), ov::float16(15), ov::float16(16), ov::float16(17), ov::float16(18), ov::float16(19), ov::float16(10), ov::float16(17), ov::float16(18),
ov::float16(21), ov::float16(22), ov::float16(23), ov::float16(24), ov::float16(25), ov::float16(26), ov::float16(27), ov::float16(28), ov::float16(29), ov::float16(20), ov::float16(27), ov::float16(28),
ov::float16(31), ov::float16(32), ov::float16(33), ov::float16(34), ov::float16(35), ov::float16(36), ov::float16(37), ov::float16(38), ov::float16(39), ov::float16(30), ov::float16(29), ov::float16(30),
});
set_values(input2, {
FLOAT16(1), FLOAT16(1), FLOAT16(1), FLOAT16(1), FLOAT16(1), FLOAT16(1),
FLOAT16(0), FLOAT16(0), FLOAT16(0), FLOAT16(0), FLOAT16(0), FLOAT16(0),
FLOAT16(1), FLOAT16(0), FLOAT16(0), FLOAT16(1), FLOAT16(1), FLOAT16(0),
ov::float16(1), ov::float16(1), ov::float16(1), ov::float16(1), ov::float16(1), ov::float16(1),
ov::float16(0), ov::float16(0), ov::float16(0), ov::float16(0), ov::float16(0), ov::float16(0),
ov::float16(1), ov::float16(0), ov::float16(0), ov::float16(1), ov::float16(1), ov::float16(0),
FLOAT16(1), FLOAT16(1), FLOAT16(1), FLOAT16(1), FLOAT16(1), FLOAT16(1),
FLOAT16(0), FLOAT16(0), FLOAT16(0), FLOAT16(0), FLOAT16(0), FLOAT16(0),
FLOAT16(1), FLOAT16(0), FLOAT16(0), FLOAT16(1), FLOAT16(1), FLOAT16(0),
ov::float16(1), ov::float16(1), ov::float16(1), ov::float16(1), ov::float16(1), ov::float16(1),
ov::float16(0), ov::float16(0), ov::float16(0), ov::float16(0), ov::float16(0), ov::float16(0),
ov::float16(1), ov::float16(0), ov::float16(0), ov::float16(1), ov::float16(1), ov::float16(0),
});
std::vector<float> expected_results = {
FLOAT16(12), FLOAT16(14), FLOAT16(16), FLOAT16(18), FLOAT16(10), FLOAT16(18),
FLOAT16(21), FLOAT16(23), FLOAT16(25), FLOAT16(27), FLOAT16(29), FLOAT16(27),
FLOAT16(32), FLOAT16(33), FLOAT16(35), FLOAT16(38), FLOAT16(30), FLOAT16(31),
ov::float16(12), ov::float16(14), ov::float16(16), ov::float16(18), ov::float16(10), ov::float16(18),
ov::float16(21), ov::float16(23), ov::float16(25), ov::float16(27), ov::float16(29), ov::float16(27),
ov::float16(32), ov::float16(33), ov::float16(35), ov::float16(38), ov::float16(30), ov::float16(31),
FLOAT16(12), FLOAT16(14), FLOAT16(16), FLOAT16(18), FLOAT16(10), FLOAT16(18),
FLOAT16(21), FLOAT16(23), FLOAT16(25), FLOAT16(27), FLOAT16(29), FLOAT16(27),
FLOAT16(32), FLOAT16(33), FLOAT16(35), FLOAT16(38), FLOAT16(30), FLOAT16(29),
ov::float16(12), ov::float16(14), ov::float16(16), ov::float16(18), ov::float16(10), ov::float16(18),
ov::float16(21), ov::float16(23), ov::float16(25), ov::float16(27), ov::float16(29), ov::float16(27),
ov::float16(32), ov::float16(33), ov::float16(35), ov::float16(38), ov::float16(30), ov::float16(29),
};
auto expected_fmt = format::bfyx;
@ -952,4 +952,4 @@ TEST(gather_nd_gpu_fp16, dynamic_r5) {
for (size_t i = 0; i < expected_results.size(); ++i) {
EXPECT_EQ(expected_results[i], half_to_float(output_ptr[i])) << i;
}
}
}

2
src/plugins/intel_gpu/tests/unit/test_cases/gather_tree_gpu_test.cpp
View File

@ -168,7 +168,7 @@ struct gather_tree_test
: public ::testing::TestWithParam<ParamsWithLayout<T> > {
public:
void test() {
const auto data_type = type_to_data_type<T>::value;
const auto data_type = ov::element::from<T>();
Params<T> params;
format::type plain_layout;
format::type target_layout;

20
src/plugins/intel_gpu/tests/unit/test_cases/gemm_gpu_test.cpp
View File

@ -1436,7 +1436,7 @@ public:
VF<uint8_t> rnd_vec = rg.generate_random_1d<uint8_t>(s.count(), -200, 200);
set_values(prim, rnd_vec);
} else if (l.data_type == cldnn::data_types::f16) {
VF<FLOAT16> rnd_vec = rg.generate_random_1d<FLOAT16>(s.count(), -1, 1);
VF<ov::float16> rnd_vec = rg.generate_random_1d<ov::float16>(s.count(), -1, 1);
set_values(prim, rnd_vec);
} else {
VF<float> rnd_vec = rg.generate_random_1d<float>(s.count(), -1, 1);
@ -1604,7 +1604,7 @@ INSTANTIATE_TEST_SUITE_P(gemm_gpu, gemm_uint8_simple_tests_onednn, ::testing::Va
gemm_base_test_params{ CASE_GEMM_UINT8_ONEDNN_4, "" },
}));
class gemm_fp16_simple_tests_onednn : public ::GemmBaseOneDNNTest<gemm_base_test_params, FLOAT16, FLOAT16, FLOAT16, FLOAT16, FLOAT16> {};
class gemm_fp16_simple_tests_onednn : public ::GemmBaseOneDNNTest<gemm_base_test_params, ov::float16, ov::float16, ov::float16, ov::float16, ov::float16> {};
TEST_P(gemm_fp16_simple_tests_onednn, basic) { auto p = GetParam(); execute(p); }
INSTANTIATE_TEST_SUITE_P(gemm_gpu, gemm_fp16_simple_tests_onednn, ::testing::ValuesIn(std::vector <gemm_base_test_params> {
@ -1654,7 +1654,7 @@ INSTANTIATE_TEST_SUITE_P(gemm_gpu, gemm_uint8_transposition_tests_onednn, ::test
gemm_base_test_params{ CASE_GEMM_UINT8_TT_TRANSPOSITION_LEFTOVERS_ONEDNN, "" },
}));
class gemm_fp16_transposition_tests_onednn : public ::GemmBaseOneDNNTest<gemm_base_test_params, FLOAT16, FLOAT16, FLOAT16, FLOAT16, FLOAT16> {};
class gemm_fp16_transposition_tests_onednn : public ::GemmBaseOneDNNTest<gemm_base_test_params, ov::float16, ov::float16, ov::float16, ov::float16, ov::float16> {};
TEST_P(gemm_fp16_transposition_tests_onednn, basic) { auto p = GetParam(); execute(p); }
INSTANTIATE_TEST_SUITE_P(gemm_gpu, gemm_fp16_transposition_tests_onednn, ::testing::ValuesIn(std::vector <gemm_base_test_params> {
@ -1684,7 +1684,7 @@ INSTANTIATE_TEST_SUITE_P(gemm_gpu, gemm_int8_broadcasting_tests_onednn, ::testin
gemm_base_test_params{ CASE_GEMM_INT8_BROADCASTING_ONEDNN_4, "" },
}));
class gemm_fp16_broadcasting_tests_onednn : public ::GemmBaseOneDNNTest<gemm_base_test_params, FLOAT16, FLOAT16, FLOAT16, FLOAT16, FLOAT16> {};
class gemm_fp16_broadcasting_tests_onednn : public ::GemmBaseOneDNNTest<gemm_base_test_params, ov::float16, ov::float16, ov::float16, ov::float16, ov::float16> {};
TEST_P(gemm_fp16_broadcasting_tests_onednn, basic) { auto p = GetParam(); execute(p); }
INSTANTIATE_TEST_SUITE_P(gemm_gpu, gemm_fp16_broadcasting_tests_onednn, ::testing::ValuesIn(std::vector <gemm_base_test_params> {
@ -1724,7 +1724,7 @@ INSTANTIATE_TEST_SUITE_P(gemm_gpu, gemm_uint8_combo_tests_onednn, ::testing::Val
gemm_base_test_params{ CASE_GEMM_UINT8_COMBO_ONEDNN_4, "" },
}));
class gemm_fp16_combo_tests_onednn : public ::GemmBaseOneDNNTest<gemm_base_test_params, FLOAT16, FLOAT16, FLOAT16, FLOAT16, FLOAT16> {};
class gemm_fp16_combo_tests_onednn : public ::GemmBaseOneDNNTest<gemm_base_test_params, ov::float16, ov::float16, ov::float16, ov::float16, ov::float16> {};
TEST_P(gemm_fp16_combo_tests_onednn, basic) { auto p = GetParam(); execute(p); }
INSTANTIATE_TEST_SUITE_P(gemm_gpu, gemm_fp16_combo_tests_onednn, ::testing::ValuesIn(std::vector <gemm_base_test_params> {
@ -1854,7 +1854,7 @@ INSTANTIATE_TEST_SUITE_P(gemm_gpu, gemm_fp32_tiled_nn_broadcast_tests, ::testing
gemm_base_test_params{ CASE_GEMM_FP32_TILED_NN_BROADCAST_4, "gemm_tiled_opt" },
}));
class gemm_fp16_tiled_nn_tests : public ::GemmBaseTest<gemm_base_test_params, FLOAT16, FLOAT16, FLOAT16, FLOAT16, FLOAT16> {};
class gemm_fp16_tiled_nn_tests : public ::GemmBaseTest<gemm_base_test_params, ov::float16, ov::float16, ov::float16, ov::float16, ov::float16> {};
TEST_P(gemm_fp16_tiled_nn_tests, basic) { auto p = GetParam(); execute(p); }
INSTANTIATE_TEST_SUITE_P(gemm_gpu, gemm_fp16_tiled_nn_tests, ::testing::ValuesIn(std::vector <gemm_base_test_params> {
@ -1864,7 +1864,7 @@ INSTANTIATE_TEST_SUITE_P(gemm_gpu, gemm_fp16_tiled_nn_tests, ::testing::ValuesIn
gemm_base_test_params{ CASE_GEMM_FP16_TILED_NN_4, "gemm_tiled_opt" },
}));
class gemm_fp16_tiled_nt_tests : public ::GemmBaseTest<gemm_base_test_params, FLOAT16, FLOAT16, FLOAT16, FLOAT16, FLOAT16> {};
class gemm_fp16_tiled_nt_tests : public ::GemmBaseTest<gemm_base_test_params, ov::float16, ov::float16, ov::float16, ov::float16, ov::float16> {};
TEST_P(gemm_fp16_tiled_nt_tests, basic) { auto p = GetParam(); execute(p); }
INSTANTIATE_TEST_SUITE_P(gemm_gpu, gemm_fp16_tiled_nt_tests, ::testing::ValuesIn(std::vector <gemm_base_test_params> {
@ -1874,7 +1874,7 @@ INSTANTIATE_TEST_SUITE_P(gemm_gpu, gemm_fp16_tiled_nt_tests, ::testing::ValuesIn
gemm_base_test_params{ CASE_GEMM_FP16_TILED_NT_4, "gemm_tiled_opt" },
}));
class gemm_fp16_tiled_tn_tests : public ::GemmBaseTest<gemm_base_test_params, FLOAT16, FLOAT16, FLOAT16, FLOAT16, FLOAT16> {};
class gemm_fp16_tiled_tn_tests : public ::GemmBaseTest<gemm_base_test_params, ov::float16, ov::float16, ov::float16, ov::float16, ov::float16> {};
TEST_P(gemm_fp16_tiled_tn_tests, basic) { auto p = GetParam(); execute(p); }
INSTANTIATE_TEST_SUITE_P(gemm_gpu, gemm_fp16_tiled_tn_tests, ::testing::ValuesIn(std::vector <gemm_base_test_params> {
@ -1884,7 +1884,7 @@ INSTANTIATE_TEST_SUITE_P(gemm_gpu, gemm_fp16_tiled_tn_tests, ::testing::ValuesIn
gemm_base_test_params{ CASE_GEMM_FP16_TILED_TN_4, "gemm_tiled_opt" },
}));
class gemm_fp16_tiled_tt_tests : public ::GemmBaseTest<gemm_base_test_params, FLOAT16, FLOAT16, FLOAT16, FLOAT16, FLOAT16> {};
class gemm_fp16_tiled_tt_tests : public ::GemmBaseTest<gemm_base_test_params, ov::float16, ov::float16, ov::float16, ov::float16, ov::float16> {};
TEST_P(gemm_fp16_tiled_tt_tests, basic) { auto p = GetParam(); execute(p); }
INSTANTIATE_TEST_SUITE_P(gemm_gpu, gemm_fp16_tiled_tt_tests, ::testing::ValuesIn(std::vector <gemm_base_test_params> {
@ -1894,7 +1894,7 @@ INSTANTIATE_TEST_SUITE_P(gemm_gpu, gemm_fp16_tiled_tt_tests, ::testing::ValuesIn
gemm_base_test_params{ CASE_GEMM_FP16_TILED_TT_4, "gemm_tiled_opt" },
}));
class gemm_fp16_tiled_nn_broadcast_tests : public ::GemmBaseTest<gemm_base_test_params, FLOAT16, FLOAT16, FLOAT16, FLOAT16, FLOAT16> {};
class gemm_fp16_tiled_nn_broadcast_tests : public ::GemmBaseTest<gemm_base_test_params, ov::float16, ov::float16, ov::float16, ov::float16, ov::float16> {};
TEST_P(gemm_fp16_tiled_nn_broadcast_tests, basic) { auto p = GetParam(); execute(p); }
INSTANTIATE_TEST_SUITE_P(gemm_gpu, gemm_fp16_tiled_nn_broadcast_tests, ::testing::ValuesIn(std::vector <gemm_base_test_params> {

16
src/plugins/intel_gpu/tests/unit/test_cases/generate_proposals_gpu_test.cpp
View File

@ -162,7 +162,7 @@ float getError<float>() {
}
template<>
float getError<half_t>() {
float getError<ov::float16>() {
return 0.2;
}
@ -286,8 +286,8 @@ public:
std::tie(param, data_layout, is_caching_test) = this->GetParam();
const bool need_reorder = data_layout != format::bfyx;
const auto data_type = type_to_data_type<T>::value;
const auto rois_num_type = type_to_data_type<ROIS_NUM_T>::value;
const auto data_type = ov::element::from<T>();
const auto rois_num_type = ov::element::from<ROIS_NUM_T>();
auto& engine = get_test_engine();
std::shared_ptr<cldnn::stream> stream = get_test_stream_ptr();;
@ -442,7 +442,7 @@ INSTANTIATE_TEST_SUITE_P(
::testing::Values(false)
));
using f16_i32 = generate_proposals_test<half_t, int32_t>;
using f16_i32 = generate_proposals_test<ov::float16, int32_t>;
TEST_P(f16_i32, f16_i32) {
test();
}
@ -450,12 +450,12 @@ INSTANTIATE_TEST_SUITE_P(
generate_proposals_gpu_test,
f16_i32,
::testing::Combine(
::testing::ValuesIn(getGenerateProposalsParams<half_t>()),
::testing::ValuesIn(getGenerateProposalsParams<ov::float16>()),
::testing::ValuesIn(layouts),
::testing::Values(false)
));
using f16_i64 = generate_proposals_test<half_t, int64_t>;
using f16_i64 = generate_proposals_test<ov::float16, int64_t>;
TEST_P(f16_i64, f16_i64) {
test();
}
@ -463,7 +463,7 @@ INSTANTIATE_TEST_SUITE_P(
generate_proposals_gpu_test,
f16_i64,
::testing::Combine(
::testing::ValuesIn(getGenerateProposalsParams<half_t>()),
::testing::ValuesIn(getGenerateProposalsParams<ov::float16>()),
::testing::ValuesIn(layouts),
::testing::Values(false)
));
@ -472,7 +472,7 @@ INSTANTIATE_TEST_SUITE_P(
export_import_generate_proposals_gpu_test,
f16_i64,
::testing::Combine(
::testing::Values(getGenerateProposalsParams<half_t>()[0]),
::testing::Values(getGenerateProposalsParams<ov::float16>()[0]),
::testing::Values(layouts[0]),
::testing::Values(true)
));

12
src/plugins/intel_gpu/tests/unit/test_cases/grid_sample_gpu_test.cpp
View File

@ -41,7 +41,7 @@ float getError<float>() {
}
template <>
float getError<FLOAT16>() {
float getError<ov::float16>() {
return 0.5f;
}
@ -55,8 +55,8 @@ public:
std::tie(p, fmt, is_caching_test) = testing::TestWithParam<grid_sample_test_params<TD, TG>>::GetParam();
auto& engine = get_test_engine();
const auto data_data_type = type_to_data_type<TD>::value;
const auto grid_data_type = type_to_data_type<TG>::value;
const auto data_data_type = ov::element::from<TD>();
const auto grid_data_type = ov::element::from<TG>();
const auto plane_format = format::bfyx;
const layout data_layout(data_data_type, plane_format, tensor(plane_format, p.data_shape));
@ -674,7 +674,7 @@ TEST_P(grid_sample_gpu_test_float_float, test) {
ASSERT_NO_FATAL_FAILURE(test());
}
using grid_sample_gpu_test_FLOAT16_FLOAT16 = grid_sample_gpu_test<FLOAT16, FLOAT16>;
using grid_sample_gpu_test_FLOAT16_FLOAT16 = grid_sample_gpu_test<ov::float16, ov::float16>;
TEST_P(grid_sample_gpu_test_FLOAT16_FLOAT16, test) {
ASSERT_NO_FATAL_FAILURE(test());
}
@ -688,7 +688,7 @@ INSTANTIATE_TEST_SUITE_P(smoke_grid_sample_gpu_test_float_float,
INSTANTIATE_TEST_SUITE_P(smoke_grid_sample_gpu_test_FLOAT16_FLOAT16,
grid_sample_gpu_test_FLOAT16_FLOAT16,
testing::Combine(testing::ValuesIn(getParamsToCheckLogic<FLOAT16, FLOAT16>()),
testing::Combine(testing::ValuesIn(getParamsToCheckLogic<ov::float16, ov::float16>()),
testing::Values(format::bfyx),
testing::Values(RUN_CACHING_TEST)),
grid_sample_gpu_test_FLOAT16_FLOAT16::PrintToStringParamName);
@ -696,7 +696,7 @@ INSTANTIATE_TEST_SUITE_P(smoke_grid_sample_gpu_test_FLOAT16_FLOAT16,
#ifndef RUN_ALL_MODEL_CACHING_TESTS
INSTANTIATE_TEST_SUITE_P(smoke_grid_sample_gpu_test_FLOAT16_FLOAT16_cached,
grid_sample_gpu_test_FLOAT16_FLOAT16,
testing::Combine(testing::ValuesIn(getNearestParamsOddDimensionsOuterGrids<FLOAT16, FLOAT16>()),
testing::Combine(testing::ValuesIn(getNearestParamsOddDimensionsOuterGrids<ov::float16, ov::float16>()),
testing::Values(format::bfyx),
testing::Values(true)),
grid_sample_gpu_test_FLOAT16_FLOAT16::PrintToStringParamName);

20
src/plugins/intel_gpu/tests/unit/test_cases/hash_key_gpu_test.cpp
View File

@ -44,7 +44,7 @@ public:
const auto params_hash = prim_inst->get_impl_params()->hash();
ASSERT_EQ(primitive_hash, 4145865612957978777UL);
ASSERT_EQ(params_hash, 14779472302025859443UL);
ASSERT_EQ(params_hash, 13330229854511334999UL);
}
void test_fc_basic(bool is_caching_test) {
@ -72,10 +72,10 @@ public:
const auto params_hash = primitve->type->get_fake_aligned_params(*prim_inst->get_impl_params()).hash();
if (!engine.get_device_info().supports_immad) {
ASSERT_EQ(primitive_hash, 6924775129729406941UL);
ASSERT_EQ(params_hash, 15366394052020805414UL);
ASSERT_EQ(params_hash, 8142839956977133460UL);
} else {
ASSERT_EQ(primitive_hash, 6924775129729406941UL);
ASSERT_EQ(params_hash, 8552673460001178483UL);
ASSERT_EQ(params_hash, 9266224209991282259UL);
}
}
@ -105,7 +105,7 @@ public:
const auto params_hash = prim_inst->get_impl_params()->hash();
ASSERT_EQ(primitive_hash, 93320679543770233UL);
ASSERT_EQ(params_hash, 16130855364209139301UL);
ASSERT_EQ(params_hash, 1542578941420280552UL);
}
void test_gemm_basic(bool is_caching_test) {
@ -128,7 +128,7 @@ public:
const auto primitive_hash = primitve->hash();
const auto params_hash = prim_inst->get_impl_params()->hash();
ASSERT_EQ(primitive_hash, 8009877756431655269UL);
ASSERT_EQ(params_hash, 16181383969029667789UL);
ASSERT_EQ(params_hash, 12585836190897043350UL);
}
void test_permute_basic(bool is_caching_test) {
@ -149,7 +149,7 @@ public:
const auto params_hash = prim_inst->get_impl_params()->hash();
ASSERT_EQ(primitive_hash, 4658575237077439700UL);
ASSERT_EQ(params_hash, 5773472682005147183UL);
ASSERT_EQ(params_hash, 10588150284756843899UL);
}
void test_reorder_basic(bool is_caching_test) {
@ -176,7 +176,7 @@ public:
const auto params_hash = prim_inst->get_impl_params()->hash();
ASSERT_EQ(primitive_hash, 16293979194373117693UL);
ASSERT_EQ(params_hash, 550629972043680951UL);
ASSERT_EQ(params_hash, 14231564068060955575UL);
}
void test_reshape_basic(bool is_caching_test) {
@ -200,7 +200,7 @@ public:
const auto params_hash = prim_inst->get_impl_params()->hash();
ASSERT_EQ(primitive_hash, 1534749073560581535UL);
ASSERT_EQ(params_hash, 2578847666139139067UL);
ASSERT_EQ(params_hash, 4349925423879269352UL);
}
void test_conv_basic(bool is_caching_test) {
@ -225,7 +225,7 @@ public:
const auto params_hash = prim_inst->get_impl_params()->hash();
ASSERT_EQ(primitive_hash, 13549661972131371304UL);
ASSERT_EQ(params_hash, 2971412112872172751UL);
ASSERT_EQ(params_hash, 7127098854451559675UL);
}
void test_quantize_basic(bool is_caching_test) {
@ -255,7 +255,7 @@ public:
const auto primitive_hash = primitve->hash();
const auto params_hash = prim_inst->get_impl_params()->hash();
ASSERT_EQ(primitive_hash, 4135863035456568493UL);
ASSERT_EQ(params_hash, 881730825593882400UL);
ASSERT_EQ(params_hash, 5990757629995899044UL);
}
};

4
src/plugins/intel_gpu/tests/unit/test_cases/lrn_gpu_test.cpp
View File

@ -164,7 +164,7 @@ void test_fp16_basic1(bool is_caching_test) {
}
TEST(lrn_fp16_gpu, basic1) {
test_fp16_basic1<half_t>(false);
test_fp16_basic1<ov::float16>(false);
}
template <typename T>
@ -272,7 +272,7 @@ TEST(lrn_fp32_gpu, basic2_cached) {
}
TEST(lrn_fp16_gpu, basic1_cached) {
test_fp16_basic1<half_t>(true);
test_fp16_basic1<ov::float16>(true);
}
#endif
TEST(lrn_fp32_gpu, basic3_cached) {

4
src/plugins/intel_gpu/tests/unit/test_cases/lru_caches_gpu_test.cpp
View File

@ -133,8 +133,8 @@ struct ImplHasher {
} // namespace
TEST(lru_cache, collisions) {
auto l1 = layout{{1, 3, 80, 80}, data_types::f32, format::bfyx};
auto l2 = layout{{1, 3, 81, 141}, data_types::f32, format::bfyx};
auto l1 = layout{{1, 3, 40, 20}, data_types::f32, format::bfyx};
auto l2 = layout{{1, 3, 39, 83}, data_types::f32, format::bfyx};
auto input1_prim = std::make_shared<input_layout>("input1", l1);
auto input2_prim = std::make_shared<input_layout>("input2", l2);

6
src/plugins/intel_gpu/tests/unit/test_cases/lstm_dynamic_gpu_test.cpp
View File

@ -160,7 +160,7 @@ VVVVF<T> lstm_dynamic_input_ref(VVVVF<T>& input, VVVVF<T>& weights, VVVVF<T>& bi
}
// Convert back to output data type before storing it into the output buffer. Currently, the output
// data type may be float or FLOAT16 (half)
// data type may be float or ov::float16 (half)
tempOut[b][0][0][h] = (T)(std::tanh(val) * sigmoid(fp32_ot));
tempOut[b][1][0][h] = (T)val;
}
@ -207,7 +207,7 @@ struct lstm_dynamic_input_layer_test : public ::testing::Test
void SetUp() override {
rg.set_seed(GET_SUITE_NAME);
}
void input_single_layer_generic_test(int32_t direction, int32_t batch_size, int32_t max_sequence_len, int32_t input_size, int32_t hidden_size, std::vector<float> dynamic_lengths,
bool has_bias = false)
{
@ -539,7 +539,7 @@ struct lstm_dynamic_single_layer_test : public ::testing::Test
}
};
typedef ::testing::Types<float, FLOAT16> lstm_dynamic_test_types;
typedef ::testing::Types<float, ov::float16> lstm_dynamic_test_types;
TYPED_TEST_SUITE(lstm_dynamic_single_layer_test, lstm_dynamic_test_types);
TYPED_TEST_SUITE(lstm_dynamic_input_layer_test, lstm_dynamic_test_types);

182
src/plugins/intel_gpu/tests/unit/test_cases/lstm_gpu_test.cpp
View File

@ -116,7 +116,7 @@ VVVVF<T> lstm_elt_reference(VVVVF<T>& tempGEMM, VVVVF<T>& cell,
}
// Convert back to output data type before storing it into the output buffer. Currently, the output
// data type may be float or FLOAT16 (half)
// data type may be float or ov::float16 (half)
tempOut[b][0][0][h] = (T)(std::tanh(val) * sigmoid(fp32_ot));
tempOut[b][1][0][h] = (T)val;
}
@ -418,12 +418,12 @@ void generic_lstm_custom_gpu_test(int sequence_len, int direction, int batch_siz
hasBias, hasInitialHidden, hasInitialCell);
auto& engine = get_test_engine();
memory::ptr input = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx,{ batch_size, sequence_len, input_size, 1 } });
memory::ptr weights = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx,{ 1, direction, input_size, 4 * hidden_size } });
memory::ptr recurrent = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx,{ 1, direction, hidden_size, 4 * hidden_size } });
memory::ptr biases = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx,{ 1, 1, 4 * hidden_size, direction } });
memory::ptr hidden = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx,{ batch_size, direction, hidden_size, 1 } });
memory::ptr cell = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx,{ batch_size, direction, hidden_size, 1 } });
memory::ptr input = engine.allocate_memory({ ov::element::from<T>(), format::bfyx,{ batch_size, sequence_len, input_size, 1 } });
memory::ptr weights = engine.allocate_memory({ ov::element::from<T>(), format::bfyx,{ 1, direction, input_size, 4 * hidden_size } });
memory::ptr recurrent = engine.allocate_memory({ ov::element::from<T>(), format::bfyx,{ 1, direction, hidden_size, 4 * hidden_size } });
memory::ptr biases = engine.allocate_memory({ ov::element::from<T>(), format::bfyx,{ 1, 1, 4 * hidden_size, direction } });
memory::ptr hidden = engine.allocate_memory({ ov::element::from<T>(), format::bfyx,{ batch_size, direction, hidden_size, 1 } });
memory::ptr cell = engine.allocate_memory({ ov::element::from<T>(), format::bfyx,{ batch_size, direction, hidden_size, 1 } });
set_values(input, ref_input_vec);
set_values(weights, ref_weights_vec);
set_values(recurrent, ref_recurrent_vec);
@ -680,12 +680,12 @@ void lstm_gpu_output_test(const lstm_output_selection& output_selection, int dir
auto& engine = get_test_engine();
memory::ptr input = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx, {batch_size, sequence_len, input_size, 1} });
memory::ptr weights = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx, { 1, directions, input_size , 4 * hidden_size } });
memory::ptr recurrent = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx, { 1, directions, hidden_size, 4 * hidden_size } });
memory::ptr biases = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx, { 1, 1, 4 * hidden_size, directions } });
memory::ptr hidden = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx, { batch_size, 1, hidden_size, directions } });
memory::ptr cell = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx, { batch_size, 1, hidden_size, directions } });
memory::ptr input = engine.allocate_memory({ ov::element::from<T>(), format::bfyx, {batch_size, sequence_len, input_size, 1} });
memory::ptr weights = engine.allocate_memory({ ov::element::from<T>(), format::bfyx, { 1, directions, input_size , 4 * hidden_size } });
memory::ptr recurrent = engine.allocate_memory({ ov::element::from<T>(), format::bfyx, { 1, directions, hidden_size, 4 * hidden_size } });
memory::ptr biases = engine.allocate_memory({ ov::element::from<T>(), format::bfyx, { 1, 1, 4 * hidden_size, directions } });
memory::ptr hidden = engine.allocate_memory({ ov::element::from<T>(), format::bfyx, { batch_size, 1, hidden_size, directions } });
memory::ptr cell = engine.allocate_memory({ ov::element::from<T>(), format::bfyx, { batch_size, 1, hidden_size, directions } });
set_values(input, ref_input_vec);
set_values(weights, ref_weights_vec);
@ -844,12 +844,12 @@ void lstm_gpu_format_test(const cldnn::format& format, int directions, bool is_c
auto& engine = get_test_engine();
memory::ptr input = engine.allocate_memory({ type_to_data_type<T>::value,format, {batch_size, sequence_len, input_size, 1} });
memory::ptr weights = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx, { 1, directions, input_size , 4 * hidden_size } });
memory::ptr recurrent = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx, { 1, directions, hidden_size, 4 * hidden_size } });
memory::ptr biases = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx, { 1, 1, 4 * hidden_size, directions } });
memory::ptr hidden = engine.allocate_memory({ type_to_data_type<T>::value, format, { batch_size, 1, hidden_size, directions } });
memory::ptr cell = engine.allocate_memory({ type_to_data_type<T>::value, format, { batch_size, 1, hidden_size, directions } });
memory::ptr input = engine.allocate_memory({ ov::element::from<T>(),format, {batch_size, sequence_len, input_size, 1} });
memory::ptr weights = engine.allocate_memory({ ov::element::from<T>(), format::bfyx, { 1, directions, input_size , 4 * hidden_size } });
memory::ptr recurrent = engine.allocate_memory({ ov::element::from<T>(), format::bfyx, { 1, directions, hidden_size, 4 * hidden_size } });
memory::ptr biases = engine.allocate_memory({ ov::element::from<T>(), format::bfyx, { 1, 1, 4 * hidden_size, directions } });
memory::ptr hidden = engine.allocate_memory({ ov::element::from<T>(), format, { batch_size, 1, hidden_size, directions } });
memory::ptr cell = engine.allocate_memory({ ov::element::from<T>(), format, { batch_size, 1, hidden_size, directions } });
set_values(input, ref_input_vec);
set_values(weights, ref_weights_vec);
@ -1025,12 +1025,12 @@ void lstm_gpu_users_test(bool is_caching_test = false) {
auto& engine = get_test_engine();
memory::ptr input = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx, {batch_size, sequence_len, input_size, 1} });
memory::ptr weights = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx, { 1, directions, input_size , 4 * hidden_size } });
memory::ptr recurrent = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx, { 1, directions, hidden_size, 4 * hidden_size } });
memory::ptr biases = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx, { 1, 1, 4 * hidden_size, directions } });
memory::ptr hidden = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx, { batch_size, 1, hidden_size, directions } });
memory::ptr cell = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx, { batch_size, 1, hidden_size, directions } });
memory::ptr input = engine.allocate_memory({ ov::element::from<T>(), format::bfyx, {batch_size, sequence_len, input_size, 1} });
memory::ptr weights = engine.allocate_memory({ ov::element::from<T>(), format::bfyx, { 1, directions, input_size , 4 * hidden_size } });
memory::ptr recurrent = engine.allocate_memory({ ov::element::from<T>(), format::bfyx, { 1, directions, hidden_size, 4 * hidden_size } });
memory::ptr biases = engine.allocate_memory({ ov::element::from<T>(), format::bfyx, { 1, 1, 4 * hidden_size, directions } });
memory::ptr hidden = engine.allocate_memory({ ov::element::from<T>(), format::bfyx, { batch_size, 1, hidden_size, directions } });
memory::ptr cell = engine.allocate_memory({ ov::element::from<T>(), format::bfyx, { batch_size, 1, hidden_size, directions } });
set_values(input, ref_input_vec);
set_values(weights, ref_weights_vec);
@ -1150,7 +1150,7 @@ void lstm_gpu_concatenated_input_test(int layers, int sequence_len, int directio
auto& engine = get_test_engine();
memory::ptr input = engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx, {batch_size, sequence_len, input_size, 1} });
memory::ptr input = engine.allocate_memory({ ov::element::from<T>(), format::bfyx, {batch_size, sequence_len, input_size, 1} });
set_values(input, ref_input_vec);
std::vector<memory::ptr> weights;
@ -1159,20 +1159,20 @@ void lstm_gpu_concatenated_input_test(int layers, int sequence_len, int directio
std::vector<memory::ptr> hidden;
std::vector<memory::ptr> cell;
for (int i = 0; i < layers; ++i) {
weights.push_back(engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx, { 1, direction, i == 0 ? input_size : hidden_size, 4 * hidden_size } }));
weights.push_back(engine.allocate_memory({ ov::element::from<T>(), format::bfyx, { 1, direction, i == 0 ? input_size : hidden_size, 4 * hidden_size } }));
set_values(weights[i], ref_weights_vec[i]);
recurrent.push_back(engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx, { 1, direction, hidden_size, 4 * hidden_size } }));
recurrent.push_back(engine.allocate_memory({ ov::element::from<T>(), format::bfyx, { 1, direction, hidden_size, 4 * hidden_size } }));
set_values(recurrent[i], ref_recurrent_vec[i]);
if (has_bias) {
biases.push_back(engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx, { 1, 1, 4 * hidden_size, direction } }));
biases.push_back(engine.allocate_memory({ ov::element::from<T>(), format::bfyx, { 1, 1, 4 * hidden_size, direction } }));
set_values(biases[i], ref_bias_vec[i]);
}
if (has_initial_hidden) {
hidden.push_back(engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx, { batch_size, 1, hidden_size, direction } }));
hidden.push_back(engine.allocate_memory({ ov::element::from<T>(), format::bfyx, { batch_size, 1, hidden_size, direction } }));
set_values(hidden[i], ref_hidden_vec[i]);
}
if (has_initial_cell) {
cell.push_back(engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx, { batch_size, 1, hidden_size, direction} }));
cell.push_back(engine.allocate_memory({ ov::element::from<T>(), format::bfyx, { batch_size, 1, hidden_size, direction} }));
set_values(cell[i], ref_cell_vec[i]);
}
}
@ -1390,7 +1390,7 @@ void lstm_gpu_chain_test(int batch_size, int input_size, int hidden_size,
auto& engine = get_test_engine();
tensor input_tensor = { batch_size, sequence_len, input_size, 1 };
layout layout = { type_to_data_type<T>::value, cldnn::format::bfyx, input_tensor };
layout layout = { ov::element::from<T>(), cldnn::format::bfyx, input_tensor };
memory::ptr input = engine.allocate_memory(layout);
set_values(input, ref_input_vec);
@ -1410,27 +1410,27 @@ void lstm_gpu_chain_test(int batch_size, int input_size, int hidden_size,
std::vector<memory::ptr> per_chain_cell;
for (size_t layer = 0; layer < layers; layer++) {
per_chain_weights.push_back(engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx, {1, directions, layer == 0 ? input_size : hidden_size, 4 * hidden_size} }));
per_chain_weights.push_back(engine.allocate_memory({ ov::element::from<T>(), format::bfyx, {1, directions, layer == 0 ? input_size : hidden_size, 4 * hidden_size} }));
set_values(per_chain_weights[layer], ref_weights_vec[chain][layer]);
per_chain_recurrent.push_back(engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx, {1, directions, hidden_size, 4 * hidden_size} }));
per_chain_recurrent.push_back(engine.allocate_memory({ ov::element::from<T>(), format::bfyx, {1, directions, hidden_size, 4 * hidden_size} }));
set_values(per_chain_recurrent[layer], ref_recurrent_vec[chain][layer]);
if (has_bias)
{
per_chain_biases.push_back(engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx, {1, 1, 4 * hidden_size, directions} }));
per_chain_biases.push_back(engine.allocate_memory({ ov::element::from<T>(), format::bfyx, {1, 1, 4 * hidden_size, directions} }));
set_values(per_chain_biases[layer], ref_bias_vec[chain][layer]);
}
if (has_initial_hidden)
{
per_chain_hidden.push_back(engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx, {1, 1, hidden_size, directions} }));
per_chain_hidden.push_back(engine.allocate_memory({ ov::element::from<T>(), format::bfyx, {1, 1, hidden_size, directions} }));
set_values(per_chain_hidden[layer], ref_hidden_vec[chain][layer]);
}
if (has_initial_cell)
{
per_chain_cell.push_back(engine.allocate_memory({ type_to_data_type<T>::value, format::bfyx, {1, 1, hidden_size, directions} }));
per_chain_cell.push_back(engine.allocate_memory({ ov::element::from<T>(), format::bfyx, {1, 1, hidden_size, directions} }));
set_values(per_chain_cell[layer], ref_cell_vec[chain][layer]);
}
}
@ -1935,115 +1935,115 @@ TEST(lstm_gpu, generic_lstm_chained_stacked_bidirectional_f32) {
// FP16 Half precision tests
TEST(lstm_gemm_gpu, generic_lstm_gemm_test_f16) {
generic_lstm_gemm_gpu_test<FLOAT16>(1, 1, 3, 6, 2, true, true);
generic_lstm_gemm_gpu_test<ov::float16>(1, 1, 3, 6, 2, true, true);
}
TEST(lstm_gemm_gpu, generic_lstm_gemm_no_bias_f16) {
generic_lstm_gemm_gpu_test<FLOAT16>(1, 1, 3, 6, 2, false, true);
generic_lstm_gemm_gpu_test<ov::float16>(1, 1, 3, 6, 2, false, true);
}
TEST(lstm_gemm_gpu, generic_lstm_gemm_no_hidden_f16) {
generic_lstm_gemm_gpu_test<FLOAT16>(1, 1, 3, 6, 2, true, false);
generic_lstm_gemm_gpu_test<ov::float16>(1, 1, 3, 6, 2, true, false);
}
TEST(lstm_gemm_gpu, generic_lstm_gemm_no_hidden_bias_f16) {
generic_lstm_gemm_gpu_test<FLOAT16>(1, 1, 3, 6, 2, false, false);
generic_lstm_gemm_gpu_test<ov::float16>(1, 1, 3, 6, 2, false, false);
}
TEST(DISABLED_lstm_elt_gpu, generic_lstm_elt_test_clip_f16) {
generic_lstm_elt_gpu_test<FLOAT16>(1, 1, 4, 6, 3, true, 0.3f, false);
generic_lstm_elt_gpu_test<ov::float16>(1, 1, 4, 6, 3, true, 0.3f, false);
}
TEST(lstm_elt_gpu, generic_lstm_elt_test_input_forget_f16) {
generic_lstm_elt_gpu_test<FLOAT16>(1, 1, 4, 6, 3, true, 0.f, true);
generic_lstm_elt_gpu_test<ov::float16>(1, 1, 4, 6, 3, true, 0.f, true);
}
TEST(DISABLED_lstm_elt_gpu, generic_lstm_elt_test_clip_input_forget_f16) {
generic_lstm_elt_gpu_test<FLOAT16>(1, 1, 4, 6, 3, true, 0.5f, true);
generic_lstm_elt_gpu_test<ov::float16>(1, 1, 4, 6, 3, true, 0.5f, true);
}
TEST(lstm_elt_gpu, generic_lstm_elt_test_f16) {
generic_lstm_elt_gpu_test<FLOAT16>(1, 1, 4, 6, 3, true, 0.f, false);
generic_lstm_elt_gpu_test<ov::float16>(1, 1, 4, 6, 3, true, 0.f, false);
}
TEST(lstm_elt_gpu, generic_lstm_elt_no_cell_f16) {
generic_lstm_elt_gpu_test<FLOAT16>(1, 1, 4, 6, 3, false, 0.f, false);
generic_lstm_elt_gpu_test<ov::float16>(1, 1, 4, 6, 3, false, 0.f, false);
}
TEST(lstm_gpu, generic_lstm_f16) {
generic_lstm_gpu_test<FLOAT16>(1, 7, 1, 3, 3, 2, true, true, true, 0, false);
generic_lstm_gpu_test<ov::float16>(1, 7, 1, 3, 3, 2, true, true, true, 0, false);
}
TEST(lstm_gpu, generic_lstm_no_bias_f16) {
generic_lstm_gpu_test<FLOAT16>(1, 7, 1, 3, 3, 2, false, true, true, 0, false);
generic_lstm_gpu_test<ov::float16>(1, 7, 1, 3, 3, 2, false, true, true, 0, false);
}
TEST(lstm_gpu, generic_lstm_no_hidden_f16) {
generic_lstm_gpu_test<FLOAT16>(1, 7, 1, 5, 4, 3, true, false, true, 0, false);
generic_lstm_gpu_test<ov::float16>(1, 7, 1, 5, 4, 3, true, false, true, 0, false);
}
TEST(lstm_gpu, generic_lstm_no_bias_hidden_f16) {
generic_lstm_gpu_test<FLOAT16>(1, 7, 1, 5, 4, 3, false, false, true, 0, false);
generic_lstm_gpu_test<ov::float16>(1, 7, 1, 5, 4, 3, false, false, true, 0, false);
}
TEST(lstm_gpu, generic_lstm_no_cell_f16) {
generic_lstm_gpu_test<FLOAT16>(1, 7, 1, 5, 4, 3, true, true, false, 0, false);
generic_lstm_gpu_test<ov::float16>(1, 7, 1, 5, 4, 3, true, true, false, 0, false);
}
TEST(lstm_gpu, generic_lstm_no_bias_cell_f16) {
generic_lstm_gpu_test<FLOAT16>(1, 7, 1, 5, 4, 3, false, true, false, 0, false);
generic_lstm_gpu_test<ov::float16>(1, 7, 1, 5, 4, 3, false, true, false, 0, false);
}
TEST(lstm_gpu, generic_lstm_no_hidden_cell_f16) {
generic_lstm_gpu_test<FLOAT16>(1, 7, 1, 5, 4, 3, true, false, false, 0, false);
generic_lstm_gpu_test<ov::float16>(1, 7, 1, 5, 4, 3, true, false, false, 0, false);
}
TEST(lstm_gpu, generic_lstm_no_bias_hidden_cell_f16) {
generic_lstm_gpu_test<FLOAT16>(1, 7, 1, 5, 4, 3, false, false, false, 0, false);
generic_lstm_gpu_test<ov::float16>(1, 7, 1, 5, 4, 3, false, false, false, 0, false);
}
TEST(DISABLED_lstm_gpu, generic_lstm_clip_f16) {
generic_lstm_gpu_test<FLOAT16>(1, 7, 1, 3, 3, 2, true, true, true, 0.3f, 0);
generic_lstm_gpu_test<ov::float16>(1, 7, 1, 3, 3, 2, true, true, true, 0.3f, 0);
}
TEST(lstm_gpu, generic_lstm_input_forget_f16) {
generic_lstm_gpu_test<FLOAT16>(1, 7, 1, 3, 3, 2, true, true, true, 0.f, 1);
generic_lstm_gpu_test<ov::float16>(1, 7, 1, 3, 3, 2, true, true, true, 0.f, 1);
}
TEST(DISABLED_lstm_gpu, generic_lstm_clip_input_forget_f16) {
generic_lstm_gpu_test<FLOAT16>(1, 7, 1, 3, 3, 2, true, true, true, 0.3f, 1);
generic_lstm_gpu_test<ov::float16>(1, 7, 1, 3, 3, 2, true, true, true, 0.3f, 1);
}
TEST(lstm_gpu, generic_lstm_offset_order_ifoz_f16) {
default_offset_type = lstm_weights_order::ifoz;
generic_lstm_gpu_test<FLOAT16>(1, 7, 1, 3, 3, 2, true, true, true, 0, false);
generic_lstm_gpu_test<ov::float16>(1, 7, 1, 3, 3, 2, true, true, true, 0, false);
default_offset_type = lstm_weights_order::iofz;
}
TEST(lstm_gpu, generic_lstm_canonical_f16) {
generic_lstm_gpu_test<FLOAT16>(1, 1, 1, 1, 1, 1, true, true, true, 0, false);
generic_lstm_gpu_test<ov::float16>(1, 1, 1, 1, 1, 1, true, true, true, 0, false);
}
// bidirectional support
TEST(lstm_gpu, generic_lstm_bi_bias_f16) {
generic_lstm_gpu_test<FLOAT16>(1, 7, 2, 2, 3, 4, true, false, false, 0, false);
generic_lstm_gpu_test<ov::float16>(1, 7, 2, 2, 3, 4, true, false, false, 0, false);
}
TEST(lstm_gpu, generic_lstm_bi_bias_hidden_f16) {
generic_lstm_gpu_test<FLOAT16>(1, 7, 2, 2, 3, 4, true, true, false, 0, false);
generic_lstm_gpu_test<ov::float16>(1, 7, 2, 2, 3, 4, true, true, false, 0, false);
}
TEST(lstm_gpu, generic_lstm_bi_bias_hidden_cell_f16) {
generic_lstm_gpu_test<FLOAT16>(1, 7, 2, 2, 3, 4, true, true, true, 0, false);
generic_lstm_gpu_test<ov::float16>(1, 7, 2, 2, 3, 4, true, true, true, 0, false);
}
// multi-layer support
TEST(lstm_gpu, generic_lstm_stacked_seq_f16) {
generic_lstm_gpu_test<FLOAT16>(4, 7, 1, 3, 3, 2, true, true, true, 0, false);
generic_lstm_gpu_test<ov::float16>(4, 7, 1, 3, 3, 2, true, true, true, 0, false);
}
TEST(lstm_gpu, generic_lstm_stacked_bi_f16) {
generic_lstm_gpu_test<FLOAT16>(4, 7, 2, 3, 3, 2, true, true, true, 0, false);
generic_lstm_gpu_test<ov::float16>(4, 7, 2, 3, 3, 2, true, true, true, 0, false);
}
// TODO: Add tests for the following:
@ -2300,112 +2300,112 @@ TEST(lstm_gpu, generic_lstm_chained_stacked_bidirectional_f32_cached) {
// FP16 Half precision tests
TEST(lstm_gemm_gpu, generic_lstm_gemm_test_f16_cached) {
generic_lstm_gemm_gpu_test<FLOAT16>(1, 1, 3, 6, 2, true, true, true);
generic_lstm_gemm_gpu_test<ov::float16>(1, 1, 3, 6, 2, true, true, true);
}
TEST(lstm_gemm_gpu, generic_lstm_gemm_no_bias_f16_cached) {
generic_lstm_gemm_gpu_test<FLOAT16>(1, 1, 3, 6, 2, false, true, true);
generic_lstm_gemm_gpu_test<ov::float16>(1, 1, 3, 6, 2, false, true, true);
}
TEST(lstm_gemm_gpu, generic_lstm_gemm_no_hidden_f16_cached) {
generic_lstm_gemm_gpu_test<FLOAT16>(1, 1, 3, 6, 2, true, false, true);
generic_lstm_gemm_gpu_test<ov::float16>(1, 1, 3, 6, 2, true, false, true);
}
TEST(lstm_gemm_gpu, generic_lstm_gemm_no_hidden_bias_f16_cached) {
generic_lstm_gemm_gpu_test<FLOAT16>(1, 1, 3, 6, 2, false, false, true);
generic_lstm_gemm_gpu_test<ov::float16>(1, 1, 3, 6, 2, false, false, true);
}
TEST(DISABLED_lstm_elt_gpu, generic_lstm_elt_test_clip_f16_cached) {
generic_lstm_elt_gpu_test<FLOAT16>(1, 1, 4, 6, 3, true, 0.3f, false, true);
generic_lstm_elt_gpu_test<ov::float16>(1, 1, 4, 6, 3, true, 0.3f, false, true);
}
TEST(lstm_elt_gpu, generic_lstm_elt_test_input_forget_f16_cached) {
generic_lstm_elt_gpu_test<FLOAT16>(1, 1, 4, 6, 3, true, 0.f, true, true);
generic_lstm_elt_gpu_test<ov::float16>(1, 1, 4, 6, 3, true, 0.f, true, true);
}
TEST(DISABLED_lstm_elt_gpu, generic_lstm_elt_test_clip_input_forget_f16_cached) {
generic_lstm_elt_gpu_test<FLOAT16>(1, 1, 4, 6, 3, true, 0.5f, true, true);
generic_lstm_elt_gpu_test<ov::float16>(1, 1, 4, 6, 3, true, 0.5f, true, true);
}
TEST(lstm_elt_gpu, generic_lstm_elt_test_f16_cached) {
generic_lstm_elt_gpu_test<FLOAT16>(1, 1, 4, 6, 3, true, 0.f, false, true);
generic_lstm_elt_gpu_test<ov::float16>(1, 1, 4, 6, 3, true, 0.f, false, true);
}
TEST(lstm_elt_gpu, generic_lstm_elt_no_cell_f16_cached) {
generic_lstm_elt_gpu_test<FLOAT16>(1, 1, 4, 6, 3, false, 0.f, false, true);
generic_lstm_elt_gpu_test<ov::float16>(1, 1, 4, 6, 3, false, 0.f, false, true);
}
TEST(lstm_gpu, generic_lstm_f16_cached) {
generic_lstm_gpu_test<FLOAT16>(1, 7, 1, 3, 3, 2, true, true, true, 0, false, true);
generic_lstm_gpu_test<ov::float16>(1, 7, 1, 3, 3, 2, true, true, true, 0, false, true);
}
TEST(lstm_gpu, generic_lstm_no_bias_f16_cached) {
generic_lstm_gpu_test<FLOAT16>(1, 7, 1, 3, 3, 2, false, true, true, 0, false, true);
generic_lstm_gpu_test<ov::float16>(1, 7, 1, 3, 3, 2, false, true, true, 0, false, true);
}
TEST(lstm_gpu, generic_lstm_no_hidden_f16_cached) {
generic_lstm_gpu_test<FLOAT16>(1, 7, 1, 5, 4, 3, true, false, true, 0, false, true);
generic_lstm_gpu_test<ov::float16>(1, 7, 1, 5, 4, 3, true, false, true, 0, false, true);
}
TEST(lstm_gpu, generic_lstm_no_bias_hidden_f16_cached) {
generic_lstm_gpu_test<FLOAT16>(1, 7, 1, 5, 4, 3, false, false, true, 0, false, true);
generic_lstm_gpu_test<ov::float16>(1, 7, 1, 5, 4, 3, false, false, true, 0, false, true);
}
TEST(lstm_gpu, generic_lstm_no_cell_f16_cached) {
generic_lstm_gpu_test<FLOAT16>(1, 7, 1, 5, 4, 3, true, true, false, 0, false, true);
generic_lstm_gpu_test<ov::float16>(1, 7, 1, 5, 4, 3, true, true, false, 0, false, true);
}
TEST(lstm_gpu, generic_lstm_no_bias_cell_f16_cached) {
generic_lstm_gpu_test<FLOAT16>(1, 7, 1, 5, 4, 3, false, true, false, 0, false, true);
generic_lstm_gpu_test<ov::float16>(1, 7, 1, 5, 4, 3, false, true, false, 0, false, true);
}
TEST(lstm_gpu, generic_lstm_no_hidden_cell_f16_cached) {
generic_lstm_gpu_test<FLOAT16>(1, 7, 1, 5, 4, 3, true, false, false, 0, false, true);
generic_lstm_gpu_test<ov::float16>(1, 7, 1, 5, 4, 3, true, false, false, 0, false, true);
}
TEST(lstm_gpu, generic_lstm_no_bias_hidden_cell_f16_cached) {
generic_lstm_gpu_test<FLOAT16>(1, 7, 1, 5, 4, 3, false, false, false, 0, false, true);
generic_lstm_gpu_test<ov::float16>(1, 7, 1, 5, 4, 3, false, false, false, 0, false, true);
}
TEST(DISABLED_lstm_gpu, generic_lstm_clip_f16_cached) {
generic_lstm_gpu_test<FLOAT16>(1, 7, 1, 3, 3, 2, true, true, true, 0.3f, 0, true);
generic_lstm_gpu_test<ov::float16>(1, 7, 1, 3, 3, 2, true, true, true, 0.3f, 0, true);
}
TEST(DISABLED_lstm_gpu, generic_lstm_input_forget_f16_cached) {
generic_lstm_gpu_test<FLOAT16>(1, 7, 1, 3, 3, 2, true, true, true, 0.f, 1, true);
generic_lstm_gpu_test<ov::float16>(1, 7, 1, 3, 3, 2, true, true, true, 0.f, 1, true);
}
TEST(DISABLED_lstm_gpu, generic_lstm_clip_input_forget_f16_cached) {
generic_lstm_gpu_test<FLOAT16>(1, 7, 1, 3, 3, 2, true, true, true, 0.3f, 1, true);
generic_lstm_gpu_test<ov::float16>(1, 7, 1, 3, 3, 2, true, true, true, 0.3f, 1, true);
}
TEST(lstm_gpu, generic_lstm_offset_order_ifoz_f16_cached) {
default_offset_type = lstm_weights_order::ifoz;
generic_lstm_gpu_test<FLOAT16>(1, 7, 1, 3, 3, 2, true, true, true, 0, false, true);
generic_lstm_gpu_test<ov::float16>(1, 7, 1, 3, 3, 2, true, true, true, 0, false, true);
default_offset_type = lstm_weights_order::iofz;
}
TEST(lstm_gpu, generic_lstm_canonical_f16_cached) {
generic_lstm_gpu_test<FLOAT16>(1, 1, 1, 1, 1, 1, true, true, true, 0, false, true);
generic_lstm_gpu_test<ov::float16>(1, 1, 1, 1, 1, 1, true, true, true, 0, false, true);
}
// bidirectional support
TEST(lstm_gpu, generic_lstm_bi_bias_f16_cached) {
generic_lstm_gpu_test<FLOAT16>(1, 7, 2, 2, 3, 4, true, false, false, 0, false, true);
generic_lstm_gpu_test<ov::float16>(1, 7, 2, 2, 3, 4, true, false, false, 0, false, true);
}
TEST(lstm_gpu, generic_lstm_bi_bias_hidden_f16_cached) {
generic_lstm_gpu_test<FLOAT16>(1, 7, 2, 2, 3, 4, true, true, false, 0, false, true);
generic_lstm_gpu_test<ov::float16>(1, 7, 2, 2, 3, 4, true, true, false, 0, false, true);
}
TEST(lstm_gpu, generic_lstm_bi_bias_hidden_cell_f16_cached) {
generic_lstm_gpu_test<FLOAT16>(1, 7, 2, 2, 3, 4, true, true, true, 0, false, true);
generic_lstm_gpu_test<ov::float16>(1, 7, 2, 2, 3, 4, true, true, true, 0, false, true);
}
TEST(lstm_gpu, generic_lstm_stacked_seq_f16_cached) {
generic_lstm_gpu_test<FLOAT16>(4, 7, 1, 3, 3, 2, true, true, true, 0, false, true);
generic_lstm_gpu_test<ov::float16>(4, 7, 1, 3, 3, 2, true, true, true, 0, false, true);
}
#endif
TEST(lstm_gpu, generic_lstm_stacked_bi_f16_cached) {
generic_lstm_gpu_test<FLOAT16>(4, 7, 2, 3, 3, 2, true, true, true, 0, false, true);
generic_lstm_gpu_test<ov::float16>(4, 7, 2, 3, 3, 2, true, true, true, 0, false, true);
}

35
src/plugins/intel_gpu/tests/unit/test_cases/matrix_nms_gpu_test.cpp
View File

@ -59,7 +59,7 @@ public:
bool is_caching_test;
std::tie(test_inputs, blocked_format, is_caching_test) = testing::TestWithParam<matrix_nms_test_params>::GetParam();
const auto data_type = type_to_data_type<T>::value;
const auto data_type = ov::element::from<T>();
const auto plain_format = format::bfyx;
auto& engine = get_test_engine();
@ -666,26 +666,27 @@ INSTANTIATE_MATRIX_NMS_TEST_SUITE(float, get_matrix_nms_top_k_inputs)
INSTANTIATE_MATRIX_NMS_TEST_SUITE(float, get_matrix_nms_single_box_inputs)
INSTANTIATE_MATRIX_NMS_TEST_SUITE(float, get_matrix_nms_no_output_inputs)
INSTANTIATE_MATRIX_NMS_TEST_SUITE(FLOAT16, get_matrix_nms_smoke_inputs)
INSTANTIATE_MATRIX_NMS_TEST_SUITE(FLOAT16, get_matrix_nms_gaussian_inputs)
INSTANTIATE_MATRIX_NMS_TEST_SUITE(FLOAT16, get_matrix_nms_two_batches_two_classes_inputs)
INSTANTIATE_MATRIX_NMS_TEST_SUITE(FLOAT16, get_matrix_nms_by_keep_top_k_inputs)
INSTANTIATE_MATRIX_NMS_TEST_SUITE(FLOAT16, get_matrix_nms_two_batches_two_classes_by_classid_cross_batch_inputs)
INSTANTIATE_MATRIX_NMS_TEST_SUITE(FLOAT16, get_matrix_nms_two_batches_two_classes_by_score_cross_batch_inputs)
INSTANTIATE_MATRIX_NMS_TEST_SUITE(FLOAT16, get_matrix_nms_background_inputs)
INSTANTIATE_MATRIX_NMS_TEST_SUITE(FLOAT16, get_matrix_nms_flipped_coordinates_inputs)
INSTANTIATE_MATRIX_NMS_TEST_SUITE(FLOAT16, get_matrix_nms_post_threshold_inputs)
INSTANTIATE_MATRIX_NMS_TEST_SUITE(FLOAT16, get_matrix_nms_identical_boxes_inputs)
INSTANTIATE_MATRIX_NMS_TEST_SUITE(FLOAT16, get_matrix_nms_top_k_inputs)
INSTANTIATE_MATRIX_NMS_TEST_SUITE(FLOAT16, get_matrix_nms_single_box_inputs)
INSTANTIATE_MATRIX_NMS_TEST_SUITE(FLOAT16, get_matrix_nms_no_output_inputs)
using ov::float16;
INSTANTIATE_MATRIX_NMS_TEST_SUITE(float16, get_matrix_nms_smoke_inputs)
INSTANTIATE_MATRIX_NMS_TEST_SUITE(float16, get_matrix_nms_gaussian_inputs)
INSTANTIATE_MATRIX_NMS_TEST_SUITE(float16, get_matrix_nms_two_batches_two_classes_inputs)
INSTANTIATE_MATRIX_NMS_TEST_SUITE(float16, get_matrix_nms_by_keep_top_k_inputs)
INSTANTIATE_MATRIX_NMS_TEST_SUITE(float16, get_matrix_nms_two_batches_two_classes_by_classid_cross_batch_inputs)
INSTANTIATE_MATRIX_NMS_TEST_SUITE(float16, get_matrix_nms_two_batches_two_classes_by_score_cross_batch_inputs)
INSTANTIATE_MATRIX_NMS_TEST_SUITE(float16, get_matrix_nms_background_inputs)
INSTANTIATE_MATRIX_NMS_TEST_SUITE(float16, get_matrix_nms_flipped_coordinates_inputs)
INSTANTIATE_MATRIX_NMS_TEST_SUITE(float16, get_matrix_nms_post_threshold_inputs)
INSTANTIATE_MATRIX_NMS_TEST_SUITE(float16, get_matrix_nms_identical_boxes_inputs)
INSTANTIATE_MATRIX_NMS_TEST_SUITE(float16, get_matrix_nms_top_k_inputs)
INSTANTIATE_MATRIX_NMS_TEST_SUITE(float16, get_matrix_nms_single_box_inputs)
INSTANTIATE_MATRIX_NMS_TEST_SUITE(float16, get_matrix_nms_no_output_inputs)
#ifndef RUN_ALL_MODEL_CACHING_TESTS
INSTANTIATE_TEST_SUITE_P(matrix_nms_test_FLOAT16get_matrix_nms_smoke_inputs_cached,
matrix_nms_gpu_test_FLOAT16get_matrix_nms_smoke_inputs,
INSTANTIATE_TEST_SUITE_P(matrix_nms_test_float16get_matrix_nms_smoke_inputs_cached,
matrix_nms_gpu_test_float16get_matrix_nms_smoke_inputs,
testing::Combine(testing::Values(get_matrix_nms_smoke_inputs()), testing::ValuesIn(layout_formats),
testing::Values(true)),
matrix_nms_gpu_test_FLOAT16get_matrix_nms_smoke_inputs::PrintToStringParamName);
matrix_nms_gpu_test_float16get_matrix_nms_smoke_inputs::PrintToStringParamName);
#endif
#undef INSTANTIATE_MATRIX_NMS_TEST_SUITE

16
src/plugins/intel_gpu/tests/unit/test_cases/multiclass_nms_gpu_test.cpp
View File

@ -27,7 +27,7 @@ float getError<float>() {
}
template<>
float getError<half_t>() {
float getError<ov::float16>() {
return 0.2;
}
@ -66,8 +66,8 @@ struct multiclass_nms_test : public ::testing::TestWithParam<MulticlassNmsParams
public:
void test(const std::vector<format::type>& formats = {format::bfyx}) {
const MulticlassNmsParams<T, T_IND> param = testing::TestWithParam<MulticlassNmsParams<T, T_IND>>::GetParam();
auto data_type = type_to_data_type<T>::value;
auto index_data_type = type_to_data_type<T_IND>::value;
auto data_type = ov::element::from<T>();
auto index_data_type = ov::element::from<T_IND>();
constexpr auto plain_format = format::bfyx;
for (const auto target_format : formats) {
@ -240,14 +240,14 @@ struct PrintToStringParamName {
const auto &p = info.param;
std::ostringstream result;
result << p.test_name << "_";
result << "InputType=" << data_type_traits::name(type_to_data_type<T_IND>::value) << "_";
result << "DataType=" << data_type_traits::name(type_to_data_type<T>::value);
result << "InputType=" << ov::element::Type(ov::element::from<T_IND>()) << "_";
result << "DataType=" << ov::element::Type(ov::element::from<T>());
return result.str();
}
};
using multiclass_nms_test_f32_i32 = multiclass_nms_test<float, int32_t>;
using multiclass_nms_test_f16_i64 = multiclass_nms_test<half_t, int64_t>;
using multiclass_nms_test_f16_i64 = multiclass_nms_test<ov::float16, int64_t>;
using multiclass_nms_test_blocked = multiclass_nms_test<float, int32_t>;
TEST_P(multiclass_nms_test_f32_i32, basic) {
@ -848,7 +848,7 @@ INSTANTIATE_TEST_SUITE_P(multiclass_nms_gpu_test,
INSTANTIATE_TEST_SUITE_P(multiclass_nms_gpu_test,
multiclass_nms_test_f16_i64,
::testing::ValuesIn(getMulticlassNmsParams<half_t, int64_t>()),
::testing::ValuesIn(getMulticlassNmsParams<ov::float16, int64_t>()),
PrintToStringParamName());
INSTANTIATE_TEST_SUITE_P(multiclass_nms_gpu_test_blocked,
@ -864,7 +864,7 @@ INSTANTIATE_TEST_SUITE_P(multiclass_nms_gpu_test_cached,
INSTANTIATE_TEST_SUITE_P(multiclass_nms_gpu_test_cached,
multiclass_nms_test_f16_i64,
::testing::ValuesIn(getMulticlassNmsParams<half_t, int64_t>(true)),
::testing::ValuesIn(getMulticlassNmsParams<ov::float16, int64_t>(true)),
PrintToStringParamName());
#endif
INSTANTIATE_TEST_SUITE_P(multiclass_nms_gpu_test_blocked_cached,

56
src/plugins/intel_gpu/tests/unit/test_cases/mvn_gpu_test.cpp
View File

@ -74,7 +74,7 @@ void mvn_compute_mean_within_channels(cldnn::memory::ptr output, bool normalize_
cldnn::mem_lock<T> buff(output, get_test_stream());
float err_margin = output->get_layout().data_type == data_types::f32 ? 1e-03F : 1e-02F;
float err_margin = output->get_layout().data_type == data_types::f32 ? 1e-03F : 2e-02F;
for (uint32_t b = 0; b < batch_size; ++b) {
for (uint32_t f = 0; f < feature_size; ++f) {
@ -113,7 +113,7 @@ void test_mvn_test_across_channels_outside_sqrt_bfyx(bool is_caching_test) {
auto& engine = get_test_engine();
cldnn::data_types input_data_type = std::is_same<T, FLOAT16>::value ? data_types::f16 : data_types::f32;
cldnn::data_types input_data_type = std::is_same<T, ov::float16>::value ? data_types::f16 : data_types::f32;
auto input = engine.allocate_memory({input_data_type, format::bfyx, {7, 10, 17, 13}});
@ -147,7 +147,7 @@ void test_mvn_test_across_channels_inside_sqrt_bfyx(bool is_caching_test) {
auto& engine = get_test_engine();
cldnn::data_types input_data_type = std::is_same<T, FLOAT16>::value ? data_types::f16 : data_types::f32;
cldnn::data_types input_data_type = std::is_same<T, ov::float16>::value ? data_types::f16 : data_types::f32;
auto input = engine.allocate_memory({input_data_type, format::bfyx, {7, 10, 17, 13}});
@ -174,11 +174,11 @@ TEST(mvn_gpu_test, mvn_test_across_channels_inside_sqrt_bfyx) {
}
TEST(mvn_gpu_test, mvn_test_across_channels_outside_sqrt_bfyx_fp16) {
test_mvn_test_across_channels_outside_sqrt_bfyx<FLOAT16>(false);
test_mvn_test_across_channels_outside_sqrt_bfyx<ov::float16>(false);
}
TEST(mvn_gpu_test, mvn_test_across_channels_inside_sqrt_bfyx_fp16) {
test_mvn_test_across_channels_inside_sqrt_bfyx<FLOAT16>(false);
test_mvn_test_across_channels_inside_sqrt_bfyx<ov::float16>(false);
}
TEST(mvn_gpu_test, mvn_test_across_channels_outside_sqrt_bfyx_normalize_variance) {
@ -244,7 +244,7 @@ TEST(mvn_gpu_test, mvn_test_across_channels_outside_sqrt_bfyx_normalize_variance
auto input = engine.allocate_memory({data_types::f16, format::bfyx, {7, 10, 17, 13}});
tests::set_random_values<FLOAT16>(input, true, 8, 100);
tests::set_random_values<ov::float16>(input, true, 8, 100);
topology topology;
topology.add(input_layout("input", input->get_layout()));
@ -259,7 +259,7 @@ TEST(mvn_gpu_test, mvn_test_across_channels_outside_sqrt_bfyx_normalize_variance
ASSERT_EQ(outputs.begin()->first, "mvn");
auto output = outputs.begin()->second.get_memory();
mvn_compute_mean_across_channels<FLOAT16>(output, true);
mvn_compute_mean_across_channels<ov::float16>(output, true);
}
TEST(mvn_gpu_test, mvn_test_across_channels_inside_sqrt_bfyx_normalize_variance_fp16) {
@ -271,7 +271,7 @@ TEST(mvn_gpu_test, mvn_test_across_channels_inside_sqrt_bfyx_normalize_variance_
auto input = engine.allocate_memory({data_types::f16, format::bfyx, {7, 10, 17, 13}});
tests::set_random_values<FLOAT16>(input, true, 8, 100);
tests::set_random_values<ov::float16>(input, true, 8, 100);
topology topology;
topology.add(input_layout("input", input->get_layout()));
@ -286,7 +286,7 @@ TEST(mvn_gpu_test, mvn_test_across_channels_inside_sqrt_bfyx_normalize_variance_
ASSERT_EQ(outputs.begin()->first, "mvn");
auto output = outputs.begin()->second.get_memory();
mvn_compute_mean_across_channels<FLOAT16>(output, true);
mvn_compute_mean_across_channels<ov::float16>(output, true);
}
TEST(mvn_gpu_test, dynamic_across_channels_inside_sqrt_bfyx_normalize_variance_fp16) {
@ -300,7 +300,7 @@ TEST(mvn_gpu_test, dynamic_across_channels_inside_sqrt_bfyx_normalize_variance_f
auto in_layout = layout{ov::PartialShape::dynamic(in_shape.size()), data_types::f16, format::bfyx};
auto input = engine.allocate_memory(layout{ov::PartialShape(in_shape), data_types::f16, format::bfyx});
tests::set_random_values<FLOAT16>(input, true, 8, 100);
tests::set_random_values<ov::float16>(input, true, 8, 100);
topology topology;
topology.add(input_layout("input", in_layout));
@ -321,7 +321,7 @@ TEST(mvn_gpu_test, dynamic_across_channels_inside_sqrt_bfyx_normalize_variance_f
ASSERT_EQ(outputs.begin()->first, "mvn");
auto output = outputs.begin()->second.get_memory();
mvn_compute_mean_across_channels<FLOAT16>(output, true);
mvn_compute_mean_across_channels<ov::float16>(output, true);
}
TEST(mvn_gpu_test, mvn_test_within_channels_outside_sqrt_bfyx) {
@ -387,7 +387,7 @@ TEST(mvn_gpu_test, mvn_test_within_channels_outside_sqrt_bfyx_fp16) {
auto input = engine.allocate_memory({data_types::f16, format::bfyx, {7, 10, 17, 13}});
tests::set_random_values<FLOAT16>(input, true, 8, 100);
tests::set_random_values<ov::float16>(input, true, 8, 100);
topology topology;
topology.add(input_layout("input", input->get_layout()));
@ -402,7 +402,7 @@ TEST(mvn_gpu_test, mvn_test_within_channels_outside_sqrt_bfyx_fp16) {
ASSERT_EQ(outputs.begin()->first, "mvn");
auto output = outputs.begin()->second.get_memory();
mvn_compute_mean_within_channels<FLOAT16>(output, false);
mvn_compute_mean_within_channels<ov::float16>(output, false);
}
TEST(mvn_gpu_test, mvn_test_within_channels_inside_sqrt_bfyx_fp16) {
@ -414,7 +414,7 @@ TEST(mvn_gpu_test, mvn_test_within_channels_inside_sqrt_bfyx_fp16) {
auto input = engine.allocate_memory({data_types::f16, format::bfyx, {7, 10, 17, 13}});
tests::set_random_values<FLOAT16>(input, true, 8, 100);
tests::set_random_values<ov::float16>(input, true, 8, 100);
topology topology;
topology.add(input_layout("input", input->get_layout()));
@ -429,7 +429,7 @@ TEST(mvn_gpu_test, mvn_test_within_channels_inside_sqrt_bfyx_fp16) {
ASSERT_EQ(outputs.begin()->first, "mvn");
auto output = outputs.begin()->second.get_memory();
mvn_compute_mean_within_channels<FLOAT16>(output, false);
mvn_compute_mean_within_channels<ov::float16>(output, false);
}
TEST(mvn_gpu_test, mvn_test_within_channels_outside_sqrt_bfyx_normalize_variance) {
@ -495,7 +495,7 @@ TEST(mvn_gpu_test, mvn_test_within_channels_outside_sqrt_bfyx_normalize_variance
auto input = engine.allocate_memory({data_types::f16, format::bfyx, {7, 10, 17, 13}});
tests::set_random_values<FLOAT16>(input, true, 8, 100);
tests::set_random_values<ov::float16>(input, true, 8, 100);
topology topology;
topology.add(input_layout("input", input->get_layout()));
@ -510,7 +510,7 @@ TEST(mvn_gpu_test, mvn_test_within_channels_outside_sqrt_bfyx_normalize_variance
ASSERT_EQ(outputs.begin()->first, "mvn");
auto output = outputs.begin()->second.get_memory();
mvn_compute_mean_within_channels<FLOAT16>(output, true);
mvn_compute_mean_within_channels<ov::float16>(output, true);
}
TEST(mvn_gpu_test, mvn_test_within_channels_inside_sqrt_bfyx_normalize_variance_fp16) {
@ -522,7 +522,7 @@ TEST(mvn_gpu_test, mvn_test_within_channels_inside_sqrt_bfyx_normalize_variance_
auto input = engine.allocate_memory({data_types::f16, format::bfyx, {7, 10, 17, 13}});
tests::set_random_values<FLOAT16>(input, true, 8, 100);
tests::set_random_values<ov::float16>(input, true, 8, 100);
topology topology;
topology.add(input_layout("input", input->get_layout()));
@ -537,7 +537,7 @@ TEST(mvn_gpu_test, mvn_test_within_channels_inside_sqrt_bfyx_normalize_variance_
ASSERT_EQ(outputs.begin()->first, "mvn");
auto output = outputs.begin()->second.get_memory();
mvn_compute_mean_within_channels<FLOAT16>(output, true);
mvn_compute_mean_within_channels<ov::float16>(output, true);
}
TEST(mvn_gpu_test, dynamic_within_channels_inside_sqrt_bfyx_normalize_variance_fp16) {
@ -551,7 +551,7 @@ TEST(mvn_gpu_test, dynamic_within_channels_inside_sqrt_bfyx_normalize_variance_f
auto in_layout = layout{ov::PartialShape::dynamic(in_shape.size()), data_types::f16, format::bfyx};
auto input = engine.allocate_memory(layout{ov::PartialShape(in_shape), data_types::f16, format::bfyx});
tests::set_random_values<FLOAT16>(input, true, 8, 100);
tests::set_random_values<ov::float16>(input, true, 8, 100);
topology topology;
topology.add(input_layout("input", in_layout));
@ -572,7 +572,7 @@ TEST(mvn_gpu_test, dynamic_within_channels_inside_sqrt_bfyx_normalize_variance_f
ASSERT_EQ(outputs.begin()->first, "mvn");
auto output = outputs.begin()->second.get_memory();
mvn_compute_mean_within_channels<FLOAT16>(output, true);
mvn_compute_mean_within_channels<ov::float16>(output, true);
}
struct mvn_basic_test_params {
@ -634,9 +634,9 @@ struct mvn_random_test : ::testing::TestWithParam<mvn_basic_test_params> {
}
} else if (output->get_layout().data_type == data_types::f16) {
if (across_channels) {
mvn_compute_mean_across_channels<FLOAT16>(output, normalize_variance);
mvn_compute_mean_across_channels<ov::float16>(output, normalize_variance);
} else {
mvn_compute_mean_within_channels<FLOAT16>(output, normalize_variance);
mvn_compute_mean_within_channels<ov::float16>(output, normalize_variance);
}
}
}
@ -652,7 +652,7 @@ struct mvn_random_test : ::testing::TestWithParam<mvn_basic_test_params> {
fill_random_data<float>(input, -127, 127);
break;
case data_types::f16:
fill_random_data<FLOAT16>(input, -127, 127);
fill_random_data<ov::float16>(input, -127, 127);
break;
case data_types::i8:
fill_random_data<int8_t>(input, -127, 127);
@ -848,7 +848,7 @@ struct mvn_random_test_bsv32 : ::testing::TestWithParam<mvn_basic_test_params> {
fill_random_data<float>(input, -127, 127);
break;
case data_types::f16:
fill_random_data<FLOAT16>(input, -127, 127, 1);
fill_random_data<ov::float16>(input, -127, 127, 1);
break;
case data_types::i8:
fill_random_data<int8_t>(input, -127, 127, 1);
@ -900,7 +900,7 @@ struct mvn_random_test_bsv32 : ::testing::TestWithParam<mvn_basic_test_params> {
if(output_dtype == data_types::f32) {
compare_outputs<float>(output, output_opt);
} else if (output_dtype == data_types::f16) {
compare_outputs<FLOAT16>(output, output_opt);
compare_outputs<ov::float16>(output, output_opt);
} else if (output_dtype == data_types::i8) {
compare_outputs<int8_t>(output, output_opt);
} else if (output_dtype == data_types::u8) {
@ -958,11 +958,11 @@ TEST(mvn_gpu_test, mvn_test_across_channels_inside_sqrt_bfyx_cached) {
}
TEST(mvn_gpu_test, mvn_test_across_channels_outside_sqrt_bfyx_fp16_cached) {
test_mvn_test_across_channels_outside_sqrt_bfyx<FLOAT16>(true);
test_mvn_test_across_channels_outside_sqrt_bfyx<ov::float16>(true);
}
TEST(mvn_gpu_test, mvn_test_across_channels_inside_sqrt_bfyx_fp16_cached) {
test_mvn_test_across_channels_inside_sqrt_bfyx<FLOAT16>(true);
test_mvn_test_across_channels_inside_sqrt_bfyx<ov::float16>(true);
}
TEST_P(mvn_random_test, random_cached) {

30
src/plugins/intel_gpu/tests/unit/test_cases/non_max_suppression_test.cpp
View File

@ -51,6 +51,9 @@ struct non_max_suppression_basic : public testing::Test {
// 1 1 1 0.2 -- iou 0.29
// 1 1 0 0.1 -- iou 0.43
using DataType = typename TypeWithLayout::Type;
static const format::type layout_format = TypeWithLayout::layout;
const data_types data_type = ov::element::from<DataType>();
const int batch_size = 2;
const int classes_num = 2;
const int boxes_num = 3;
@ -79,11 +82,12 @@ struct non_max_suppression_basic : public testing::Test {
};
const layout boxes_layout = layout(ov::PartialShape{batch_size, boxes_num, 4},
type_to_data_type<DataType>::value,
data_type,
format::bfyx);
const layout scores_layout = layout(ov::PartialShape{batch_size, classes_num, boxes_num},
type_to_data_type<DataType>::value,
data_type,
format::bfyx);
const layout selected_scores_layout = layout(ov::PartialShape{selected_indices_num, 3}, data_type, layout_format);
const layout valid_outputs_layout = layout(ov::PartialShape{1}, cldnn::data_types::i32, layout_format);
@ -109,8 +113,6 @@ struct non_max_suppression_basic : public testing::Test {
return mem;
}
static const format::type layout_format = TypeWithLayout::layout;
static const data_types data_type = type_to_data_type<DataType>::value;
const int pad = -1;
@ -329,10 +331,10 @@ struct non_max_suppression_basic : public testing::Test {
ASSERT_FLOAT_EQ(expected_second_out[i], second_output_ptr[i]);
}
} else {
cldnn::mem_lock<half_t> second_output_ptr(plane_scores_mem, get_test_stream());
cldnn::mem_lock<ov::float16> second_output_ptr(plane_scores_mem, get_test_stream());
for (size_t i = 0; i < expected_second_out.size(); ++i) {
ASSERT_NEAR(expected_second_out[i], half_to_float(second_output_ptr[i]), 0.0002f);
ASSERT_NEAR(expected_second_out[i], static_cast<float>(second_output_ptr[i]), 0.0002f);
}
}
@ -449,10 +451,10 @@ struct non_max_suppression_basic : public testing::Test {
ASSERT_FLOAT_EQ(expected_second_out[i], second_output_ptr[i]);
}
} else {
cldnn::mem_lock<half_t> second_output_ptr(plane_scores_mem, get_test_stream());
cldnn::mem_lock<ov::float16> second_output_ptr(plane_scores_mem, get_test_stream());
for (size_t i = 0; i < expected_second_out.size(); ++i) {
ASSERT_NEAR(expected_second_out[i], half_to_float(second_output_ptr[i]), 0.0002f);
ASSERT_NEAR(expected_second_out[i], static_cast<float>(second_output_ptr[i]), 0.0002f);
}
}
@ -643,12 +645,12 @@ using nms_types = testing::Types<TypeWithLayoutFormat<float, cldnn::format::bfyx
TypeWithLayoutFormat<float, cldnn::format::bs_fs_yx_bsv16_fsv16>,
TypeWithLayoutFormat<float, cldnn::format::bs_fs_yx_bsv32_fsv32>,
TypeWithLayoutFormat<half_t, cldnn::format::bfyx>,
TypeWithLayoutFormat<half_t, cldnn::format::b_fs_yx_fsv32>,
TypeWithLayoutFormat<half_t, cldnn::format::b_fs_yx_fsv16>,
TypeWithLayoutFormat<half_t, cldnn::format::bs_fs_yx_bsv32_fsv16>,
TypeWithLayoutFormat<half_t, cldnn::format::bs_fs_yx_bsv16_fsv16>,
TypeWithLayoutFormat<half_t, cldnn::format::bs_fs_yx_bsv32_fsv32>>;
TypeWithLayoutFormat<ov::float16, cldnn::format::bfyx>,
TypeWithLayoutFormat<ov::float16, cldnn::format::b_fs_yx_fsv32>,
TypeWithLayoutFormat<ov::float16, cldnn::format::b_fs_yx_fsv16>,
TypeWithLayoutFormat<ov::float16, cldnn::format::bs_fs_yx_bsv32_fsv16>,
TypeWithLayoutFormat<ov::float16, cldnn::format::bs_fs_yx_bsv16_fsv16>,
TypeWithLayoutFormat<ov::float16, cldnn::format::bs_fs_yx_bsv32_fsv32>>;
TYPED_TEST_SUITE(non_max_suppression_basic, nms_types);

16
src/plugins/intel_gpu/tests/unit/test_cases/non_zero_gpu_test.cpp
View File

@ -69,11 +69,11 @@ TEST(test_count_non_zero, 4d_fp32_1_2_1_5) {
}
TEST(test_count_non_zero, 5d_fp16_1_3_2_1_2) {
std::vector<FLOAT16> in_data = {
std::vector<ov::float16> in_data = {
0.1f, 0.2f, 0.3f, 0.0f, 12.1f, 11.1f,
0.0f, 0.0f, 0.1f, 0.9f, 0.10f, 0.001f
};
test_count_non_zero<FLOAT16>(layout{ov::PartialShape{1, 3, 2, 1, 2}, data_types::f16, format::bfzyx}, in_data);
test_count_non_zero<ov::float16>(layout{ov::PartialShape{1, 3, 2, 1, 2}, data_types::f16, format::bfzyx}, in_data);
}
TEST(test_count_non_zero, 2d_int32_1_256) {
@ -216,7 +216,7 @@ TEST(test_gather_non_zero, 4d_fp32_2_4_3_2) {
test_gather_non_zero<float>(layout{ov::PartialShape{2, 4, 3, 2}, data_types::f32, format::bfyx}, in_data);
}
TEST(test_gather_non_zero, 4d_fp16_2_4_3_2) {
std::vector<FLOAT16> in_data = {
std::vector<ov::float16> in_data = {
0.1f, 0.2f, 0.3f, 0.0f, 12.0f, 2.0f, 0.4f, 0.1f,
1.9f, 0.10f, 1.0f, 0.0f, 0.1f, 0.2f, 0.0f, 100.0f,
0.0001f, 0.0f, 2.9f, 0.2f, 4.0f, 0.0f, 9.1f, 0.9f,
@ -224,7 +224,7 @@ TEST(test_gather_non_zero, 4d_fp16_2_4_3_2) {
4.0f, 0.0f, 3.1f, 0.9f, 0.10f, 49.2f, 0.0f, 0.3f,
100.0f, 0.4f, 0.1f, 0.9f, 0.1f, 33.12f, 12.1f, 0.0001f
};
test_gather_non_zero<FLOAT16>(layout{ov::PartialShape{2, 4, 3, 2}, data_types::f16, format::bfyx}, in_data);
test_gather_non_zero<ov::float16>(layout{ov::PartialShape{2, 4, 3, 2}, data_types::f16, format::bfyx}, in_data);
}
TEST(test_gather_non_zero, 5d_fp32_1_3_3_2_2) {
@ -351,7 +351,7 @@ void test_non_zero(layout in_layout, std::vector<T> in_data) {
}
TEST(test_non_zero, 1d_fp16_48) {
std::vector<FLOAT16> in_data = {
std::vector<ov::float16> in_data = {
0.1f, 0.2f, 0.3f, 0.0f, 12.0f, 2.0f, 0.4f, 0.1f,
1.9f, 0.10f, 1.0f, 0.0f, 0.1f, 0.2f, 0.0f, 100.0f,
0.0001f, 0.0f, 2.9f, 0.2f, 4.0f, 0.0f, 9.1f, 0.9f,
@ -359,7 +359,7 @@ TEST(test_non_zero, 1d_fp16_48) {
4.0f, 0.0f, 3.1f, 0.9f, 0.10f, 49.2f, 0.0f, 0.3f,
100.0f, 0.4f, 0.1f, 0.9f, 0.1f, 33.12f, 12.1f, 0.0001f
};
test_non_zero<FLOAT16>(layout{ov::PartialShape{48}, data_types::f16, format::bfyx}, in_data);
test_non_zero<ov::float16>(layout{ov::PartialShape{48}, data_types::f16, format::bfyx}, in_data);
}
TEST(test_non_zero, 2d_fp32_2_34) {
@ -387,7 +387,7 @@ TEST(test_non_zero, 3d_fp16_4_3_4) {
}
TEST(test_non_zero, 4d_fp16_2_4_3_2) {
std::vector<FLOAT16> in_data = {
std::vector<ov::float16> in_data = {
0.1f, 0.2f, 0.3f, 0.0f, 12.0f, 2.0f, 0.4f, 0.1f,
1.9f, 0.10f, 1.0f, 0.0f, 0.1f, 0.2f, 0.0f, 100.0f,
0.0001f, 0.0f, 2.9f, 0.2f, 4.0f, 0.0f, 9.1f, 0.9f,
@ -395,7 +395,7 @@ TEST(test_non_zero, 4d_fp16_2_4_3_2) {
4.0f, 0.0f, 3.1f, 0.9f, 0.10f, 49.2f, 0.0f, 0.3f,
100.0f, 0.4f, 0.1f, 0.9f, 0.1f, 33.12f, 12.1f, 0.0001f
};
test_non_zero<FLOAT16>(layout{ov::PartialShape{2, 4, 3, 2}, data_types::f16, format::bfyx}, in_data);
test_non_zero<ov::float16>(layout{ov::PartialShape{2, 4, 3, 2}, data_types::f16, format::bfyx}, in_data);
}
TEST(test_non_zero, 5d_fp32_1_3_3_2_2) {

32
src/plugins/intel_gpu/tests/unit/test_cases/normalizel2_gpu_test.cpp
View File

@ -28,18 +28,16 @@ struct normalize_input_types {
static const auto format = layoutFormat;
using type = DataType;
using output_type = typename std::conditional<is_input_and_output_same<DataType>::value, DataType, float>::type;
static const data_types data_type = type_to_data_type<DataType>::value;
static const data_types output_data_type = type_to_data_type<output_type>::value;
static const bool normalize_type = across_spatial;
};
template <typename NormalizeInput>
struct normalize_basic : public testing::Test {
static const auto format = NormalizeInput::format;
static const auto data_type = NormalizeInput::data_type;
static const auto output_data_type = NormalizeInput::output_data_type;
using input_type = typename NormalizeInput::type;
using output_type = typename NormalizeInput::output_type;
const ov::element::Type data_type = ov::element::from<input_type>();
const ov::element::Type output_data_type = ov::element::from<output_type>();
static const bool across_spatial = NormalizeInput::normalize_type;
const std::vector<output_type> get_expected_result() {
return get_expected_result(std::integral_constant<bool, across_spatial>());
@ -91,7 +89,7 @@ struct normalize_basic : public testing::Test {
auto output = outputs.at("plane_normalize2").get_memory();
if (this->data_type == data_types::f16) {
cldnn::mem_lock<half_t> output_ptr(output, get_test_stream());
cldnn::mem_lock<ov::float16> output_ptr(output, get_test_stream());
auto expected_results = this->get_expected_result();
for (size_t i = 0; i < expected_results.size(); ++i) {
ASSERT_NEAR(expected_results[i], output_ptr[i], 0.001);
@ -159,12 +157,12 @@ using format_types = testing::Types<normalize_input_types<format::bfyx, float, f
normalize_input_types<format::bs_fs_yx_bsv32_fsv16, float, false>,
normalize_input_types<format::bs_fs_yx_bsv16_fsv16, float, false>,
normalize_input_types<format::bs_fs_yx_bsv32_fsv32, float, false>,
normalize_input_types<format::bfyx, half_t, false>,
normalize_input_types<format::b_fs_yx_fsv32, half_t, false>,
normalize_input_types<format::b_fs_yx_fsv16, half_t, false>,
normalize_input_types<format::bs_fs_yx_bsv32_fsv16, half_t, false>,
normalize_input_types<format::bs_fs_yx_bsv16_fsv16, half_t, false>,
normalize_input_types<format::bs_fs_yx_bsv32_fsv32, half_t, false>,
normalize_input_types<format::bfyx, ov::float16, false>,
normalize_input_types<format::b_fs_yx_fsv32, ov::float16, false>,
normalize_input_types<format::b_fs_yx_fsv16, ov::float16, false>,
normalize_input_types<format::bs_fs_yx_bsv32_fsv16, ov::float16, false>,
normalize_input_types<format::bs_fs_yx_bsv16_fsv16, ov::float16, false>,
normalize_input_types<format::bs_fs_yx_bsv32_fsv32, ov::float16, false>,
normalize_input_types<format::bfyx, int8_t, false>,
normalize_input_types<format::b_fs_yx_fsv32, int8_t, false>,
normalize_input_types<format::b_fs_yx_fsv16, int8_t, false>,
@ -179,12 +177,12 @@ using format_types = testing::Types<normalize_input_types<format::bfyx, float, f
normalize_input_types<format::bs_fs_yx_bsv32_fsv16, float, true>,
normalize_input_types<format::bs_fs_yx_bsv16_fsv16, float, true>,
normalize_input_types<format::bs_fs_yx_bsv32_fsv32, float, true>,
normalize_input_types<format::bfyx, half_t, true>,
normalize_input_types<format::b_fs_yx_fsv32, half_t, true>,
normalize_input_types<format::b_fs_yx_fsv16, half_t, true>,
normalize_input_types<format::bs_fs_yx_bsv32_fsv16, half_t, true>,
normalize_input_types<format::bs_fs_yx_bsv16_fsv16, half_t, true>,
normalize_input_types<format::bs_fs_yx_bsv32_fsv32, half_t, true>,
normalize_input_types<format::bfyx, ov::float16, true>,
normalize_input_types<format::b_fs_yx_fsv32, ov::float16, true>,
normalize_input_types<format::b_fs_yx_fsv16, ov::float16, true>,
normalize_input_types<format::bs_fs_yx_bsv32_fsv16, ov::float16, true>,
normalize_input_types<format::bs_fs_yx_bsv16_fsv16, ov::float16, true>,
normalize_input_types<format::bs_fs_yx_bsv32_fsv32, ov::float16, true>,
normalize_input_types<format::bfyx, int8_t, true>,
normalize_input_types<format::b_fs_yx_fsv32, int8_t, true>,
normalize_input_types<format::b_fs_yx_fsv16, int8_t, true>,

2
src/plugins/intel_gpu/tests/unit/test_cases/one_hot_gpu_test.cpp
View File

@ -79,7 +79,7 @@ void generic_one_hot_test_int(cldnn::format test_input_fmt, int input_b, int inp
auto& engine = get_test_engine();
tensor input_tensor(input_b, input_f, input_x, input_y);
auto input = engine.allocate_memory({ type_to_data_type<T>::value, test_input_fmt, input_tensor });
auto input = engine.allocate_memory({ ov::element::from<T>(), test_input_fmt, input_tensor });
set_values(input, input_rnd_vec);
topology topology;

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