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

[GPU] Interpolate shape infer support (#12516)

Browse Source
This commit is contained in:
Roman Lyamin
2022-08-22 10:47:07 +04:00
committed by GitHub
parent 267f2f9c4b
commit f26c3d035a
12 changed files with 365 additions and 85 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src/core/include/openvino/op/interpolate.hpp
View File

@@ -253,6 +253,9 @@ public:
const InterpolateAttrs& get_attrs() const {
return m_attrs;
}
void set_attrs(const InterpolateAttrs& attrs) {
this->m_attrs = attrs;
}
protected:
/// \return The interpolation axes.

16
src/plugins/intel_gpu/include/intel_gpu/graph/build_options.hpp
View File

@@ -60,7 +60,8 @@ enum class build_option_type {
serialize_network,
load_program,
force_implementations,
partial_build_program
partial_build_program,
allow_new_shape_infer
};
/// @brief Tuning mode.
@@ -143,6 +144,9 @@ struct build_option {
static std::shared_ptr<const build_option> force_implementations(implementation_forcing_map forcing);
static std::shared_ptr<const build_option> partial_build_program(bool set = false);
static std::shared_ptr<const build_option> allow_new_shape_infer(bool set = false);
virtual ~build_option() = default;
private:
@@ -363,12 +367,16 @@ struct build_option_traits<build_option_type::force_implementations> {
using object_type = build_option_force_implementations;
static std::shared_ptr<const build_option> make_default() { return build_option::force_implementations({}); }
};
template <>
struct build_option_traits<build_option_type::partial_build_program> {
typedef build_option_bool<build_option_type::partial_build_program> object_type;
static std::shared_ptr<const build_option> make_default() { return build_option::partial_build_program(); }
};
template <>
struct build_option_traits<build_option_type::allow_new_shape_infer> {
typedef build_option_bool<build_option_type::allow_new_shape_infer> object_type;
static std::shared_ptr<const build_option> make_default() { return build_option::allow_new_shape_infer(); }
};
#endif
} // namespace detail
@@ -423,6 +431,10 @@ inline std::shared_ptr<const build_option> build_option::partial_build_program(b
return std::make_shared<build_option_bool<build_option_type::partial_build_program>>(enable);
}
inline std::shared_ptr<const build_option> build_option::allow_new_shape_infer(bool enable) {
return std::make_shared<build_option_bool<build_option_type::allow_new_shape_infer>>(enable);
}
#endif
/// @brief Represents program build options list.

63
src/plugins/intel_gpu/include/intel_gpu/primitives/resample.hpp
View File

@@ -40,6 +40,7 @@ struct resample : public primitive_base<resample> {
: primitive_base(id, {input}, ext_prim_id, output_padding),
output_size(output_size),
num_filter(num_filter),
output_pattern({}),
scales({}),
axes({}),
pads_begin({}),
@@ -57,18 +58,14 @@ struct resample : public primitive_base<resample> {
}
}
/// @brief Constructs Resample primitive with Interpolate operation.
/// @param id This primitive id.
/// @param input Input primitive id.
/// @param pads_begin Optional begin padding for input.
/// @param pads_end Optional end padding for input.
/// @brief resample with dynamic pattern
resample(const primitive_id& id,
const primitive_id& input,
tensor output_size,
std::vector<float> scales,
std::vector<int64_t> axes,
std::vector<size_t> pads_begin = {},
std::vector<size_t> pads_end = {},
const primitive_id& pattern_id,
const std::vector<float>& scales,
const std::vector<int64_t>& axes,
const std::vector<size_t>& pads_begin = {},
const std::vector<size_t>& pads_end = {},
int32_t antialias = 0,
float cube_coeff = -0.75f,
InterpolateOp::InterpolateMode operation_type = InterpolateOp::InterpolateMode::LINEAR,
@@ -77,9 +74,10 @@ struct resample : public primitive_base<resample> {
InterpolateOp::NearestMode nm = InterpolateOp::NearestMode::ROUND_PREFER_FLOOR,
const primitive_id& ext_prim_id = "",
const padding& output_padding = padding())
: primitive_base(id, {input}, ext_prim_id, output_padding),
output_size(output_size),
: primitive_base(id, {input, pattern_id}, ext_prim_id, output_padding),
output_size(tensor()),
num_filter(0),
output_pattern({}),
scales(scales),
axes(axes),
pads_begin(pads_begin),
@@ -94,7 +92,41 @@ struct resample : public primitive_base<resample> {
throw std::runtime_error("Resample's scales/axes count does not match");
}
InterpolateOp::InterpolateAttrs get_attrs() {
/// @brief reshape with static pattern
resample(const primitive_id& id,
const primitive_id& input,
const std::vector<int64_t>& output_pattern,
const std::vector<float>& scales,
const std::vector<int64_t>& axes,
const std::vector<size_t>& pads_begin = {},
const std::vector<size_t>& pads_end = {},
int32_t antialias = 0,
float cube_coeff = -0.75f,
InterpolateOp::InterpolateMode operation_type = InterpolateOp::InterpolateMode::LINEAR,
InterpolateOp::ShapeCalcMode shape_calc_mode = InterpolateOp::ShapeCalcMode::SIZES,
InterpolateOp::CoordinateTransformMode ctm = InterpolateOp::CoordinateTransformMode::HALF_PIXEL,
InterpolateOp::NearestMode nm = InterpolateOp::NearestMode::ROUND_PREFER_FLOOR,
const primitive_id& ext_prim_id = "",
const padding& output_padding = padding())
: primitive_base(id, {input}, ext_prim_id, output_padding),
output_size(tensor()),
num_filter(0),
output_pattern(output_pattern),
scales(scales),
axes(axes),
pads_begin(pads_begin),
pads_end(pads_end),
operation_type(operation_type),
shape_calc_mode(shape_calc_mode),
antialias(antialias),
cube_coeff(cube_coeff),
coord_trans_mode(ctm),
round_mode(nm) {
if (scales.size() != axes.size())
throw std::runtime_error("Resample's scales/axes count does not match");
}
InterpolateOp::InterpolateAttrs get_attrs() const {
return InterpolateOp::InterpolateAttrs(this->operation_type,
this->shape_calc_mode,
this->pads_begin,
@@ -102,13 +134,14 @@ struct resample : public primitive_base<resample> {
this->coord_trans_mode,
this->round_mode,
static_cast<bool>(this->antialias),
cube_coeff);
this->cube_coeff);
}
/// @param scale Resample scale.
tensor output_size;
/// @param num_filter Input filter. Only used by bilinear sample_type.
uint32_t num_filter;
/// @param output_pattern Describing output shape for spatial axes.
std::vector<int64_t> output_pattern;
/// @param scales Scales of spatial axes, i.e. output_shape / input_shape
std::vector<float> scales;
/// @param axes Interpolation axes.

3
src/plugins/intel_gpu/src/graph/impls/ocl/resample.cpp
View File

@@ -81,7 +81,8 @@ inline std::vector<int32_t> convert_pads(const std::vector<size_t>& pad, size_t
new_pad = std::vector<int32_t>(rank, 0);
} else {
new_pad = std::vector<int32_t>(pad.begin(), pad.end());
std::reverse(new_pad.begin() + 2, new_pad.end());
if (new_pad.size() > 2)
std::reverse(new_pad.begin() + 2, new_pad.end());
for (size_t i = new_pad.size(); i < rank || i < 4; ++i)
new_pad.push_back(0);
}

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

@@ -33,6 +33,8 @@ class typed_primitive_inst<resample> : public typed_primitive_inst_base<resample
public:
static layout calc_output_layout(resample_node const& node, kernel_impl_params const& impl_param);
template<typename ShapeType>
static std::vector<layout> calc_output_layouts(resample_node const& node, const kernel_impl_params& impl_param);
static std::string to_string(resample_node const& node);
public:

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

@@ -226,6 +226,14 @@ bool program_node::is_detached(bool whole_branch) {
}
layout program_node::calc_output_layout() const {
bool allow_new_shape_infer =
get_program().get_options().get<build_option_type::allow_new_shape_infer>()->enabled();
if (allow_new_shape_infer) {
auto out_layouts = type()->calc_output_layouts(*this, *get_kernel_impl_params());
if (!out_layouts.empty()) {
return out_layouts[0];
}
}
return type()->calc_output_layout(*this, *get_kernel_impl_params());
}

68
src/plugins/intel_gpu/src/graph/resample.cpp
View File

@@ -9,6 +9,8 @@
#include <string>
#include "json_object.h"
#include "interpolate_shape_inference.hpp"
namespace cldnn {
primitive_type_id resample::type_id() {
static primitive_type_base<resample> instance;
@@ -28,13 +30,69 @@ layout resample_inst::calc_output_layout(resample_node const& node, kernel_impl_
output_type = impl_param.get_fused_output_layout().data_type;
}
auto result_sizes = desc->output_size;
return desc->output_pattern.empty() ? layout({output_type, input_layout.format, desc->output_size}) :
layout({desc->output_pattern, output_type, input_layout.format});
}
CLDNN_ERROR_NOT_EQUAL(desc->id, "Input batch size", input_layout.batch(), "output batch size", result_sizes.batch[0], "");
CLDNN_ERROR_NOT_EQUAL(desc->id, "Input feature size", input_layout.feature(), "output feature size", result_sizes.feature[0], "");
template<typename ShapeType>
std::vector<layout> resample_inst::calc_output_layouts(resample_node const& node, const kernel_impl_params& impl_param) {
auto desc = impl_param.typed_desc<resample>();
auto input_layout = impl_param.get_input_layout(0);
auto result = layout({output_type, input_layout.format, result_sizes});
return result;
auto& memory_deps = impl_param.memory_deps;
ov::op::v4::Interpolate op;
op.set_attrs(desc->get_attrs());
ShapeType pattern_shape = impl_param.input_layouts.size() == 2 ? impl_param.input_layouts[1].get<ShapeType>()
: ov::Shape{ desc->output_pattern.size() };
std::vector<ShapeType> output_shapes = {ShapeType()};
std::vector<ShapeType> input_shapes = {
impl_param.input_layouts[0].get<ShapeType>(),
pattern_shape,
ov::Shape{ desc->scales.size() },
ov::Shape{ desc->axes.size() }
};
std::map<size_t, ngraph::HostTensorPtr> const_data;
auto scales_data = desc->scales;
auto scales_tensor = make_host_tensor({ ov::PartialShape{ ov::Shape{scales_data.size()} }, data_types::f32, format::bfyx },
static_cast<void*>(scales_data.data()));
const_data.emplace(2, scales_tensor);
auto axes_data = desc->axes;
if (axes_data.empty()) {
axes_data.resize(input_layout.get_rank());
std::iota(axes_data.begin(), axes_data.end(), 0);
}
auto axes_tensor = make_host_tensor({ ov::PartialShape{ ov::Shape{axes_data.size()} }, data_types::i64, format::bfyx },
static_cast<void*>(axes_data.data()));
const_data.emplace(3, axes_tensor);
auto pads_begin = desc->pads_begin;
auto pads_end = desc->pads_end;
ov::op::v4::correct_pads_attr(&op, pads_begin, pads_end, input_shapes);
auto pattern_data = desc->output_pattern;
if (!memory_deps.empty()) {
auto pattern_mem = memory_deps.at(1);
cldnn::mem_lock<uint8_t, mem_lock_type::read> pattern_lock(pattern_mem, node.get_program().get_stream());
auto pattern_ptr = pattern_lock.data();
auto pattern_tensor = make_host_tensor(pattern_mem->get_layout(), pattern_ptr);
const_data.emplace(1, pattern_tensor);
ov::op::v4::shape_infer(&op, pads_begin, pads_end, input_shapes, output_shapes, {const_data});
} else {
auto pattern_tensor = make_host_tensor({ pattern_shape, data_types::i64, format::bfyx },
static_cast<void*>(pattern_data.data()));
const_data.emplace(1, pattern_tensor);
ov::op::v4::shape_infer(&op, pads_begin, pads_end, input_shapes, output_shapes, {const_data});
}
return { layout{output_shapes[0], input_layout.data_type, format::adjust_to_rank(input_layout.format, output_shapes[0].size())} };
}
std::string resample_inst::to_string(resample_node const& node) {

1
src/plugins/intel_gpu/src/graph/reshape.cpp
View File

@@ -74,7 +74,6 @@ std::vector<layout> reshape_inst::calc_output_layouts(reshape_node const& node,
pattern_shape,
};
if (!memory_deps.empty()) {
auto pattern_mem = memory_deps.at(1);

5
src/plugins/intel_gpu/src/plugin/ops/interpolate.cpp
View File

@@ -24,7 +24,8 @@ static void CreateInterpolateOp(Program& p, const std::shared_ptr<ngraph::op::v4
auto attrs = op->get_attrs();
auto inputRank = op->get_input_shape(0).size();
auto outTensor = tensor_from_dims(op->get_output_shape(0));
auto outShape = op->get_output_shape(0);
auto outputPattern = std::vector<int64_t>(outShape.begin(), outShape.end());
auto scales_constant = std::dynamic_pointer_cast<ngraph::op::Constant>(op->get_input_node_shared_ptr(SCALES_INDEX));
if (!scales_constant) {
@@ -76,7 +77,7 @@ static void CreateInterpolateOp(Program& p, const std::shared_ptr<ngraph::op::v4
auto resamplePrim = cldnn::resample(layerName,
inputPrimitives[0],
outTensor,
outputPattern,
scales,
axes,
attrs.pads_begin,

30
src/plugins/intel_gpu/tests/module_tests/format_test.cpp
View File

@@ -25,9 +25,9 @@ TEST(format, traits) {
}
struct format_adjust_test_params {
format in_format;
cldnn::format in_format;
size_t new_rank;
format expected_format;
cldnn::format expected_format;
};
class format_adjust_test : public testing::TestWithParam<format_adjust_test_params> {
@@ -44,7 +44,7 @@ public:
TEST_P(format_adjust_test, shape_infer) {
auto p = GetParam();
if (p.expected_format == format::any) {
if (p.expected_format == cldnn::format::any) {
cldnn::format fmt = cldnn::format::any;
ASSERT_ANY_THROW(fmt = format::adjust_to_rank(p.in_format, p.new_rank)) << fmt.to_string();
} else {
@@ -54,17 +54,17 @@ TEST_P(format_adjust_test, shape_infer) {
INSTANTIATE_TEST_SUITE_P(smoke, format_adjust_test,
testing::ValuesIn(std::vector<format_adjust_test_params>{
{format::bfyx, 3, format::bfyx},
{format::bfyx, 4, format::bfyx},
{format::bfyx, 5, format::bfzyx},
{format::bfyx, 6, format::bfwzyx},
{format::bfzyx, 4, format::bfyx},
{format::bfzyx, 6, format::bfwzyx},
{format::bfwzyx, 3, format::bfyx},
{format::b_fs_yx_fsv16, 5, format::b_fs_zyx_fsv16},
{format::b_fs_zyx_fsv16, 4, format::b_fs_yx_fsv16},
{format::fs_b_yx_fsv32, 5, format::any},
{format::nv12, 5, format::any},
{format::oiyx, 5, format::any},
{cldnn::format::bfyx, 3, cldnn::format::bfyx},
{cldnn::format::bfyx, 4, cldnn::format::bfyx},
{cldnn::format::bfyx, 5, cldnn::format::bfzyx},
{cldnn::format::bfyx, 6, cldnn::format::bfwzyx},
{cldnn::format::bfzyx, 4, cldnn::format::bfyx},
{cldnn::format::bfzyx, 6, cldnn::format::bfwzyx},
{cldnn::format::bfwzyx, 3, cldnn::format::bfyx},
{cldnn::format::b_fs_yx_fsv16, 5, cldnn::format::b_fs_zyx_fsv16},
{cldnn::format::b_fs_zyx_fsv16, 4, cldnn::format::b_fs_yx_fsv16},
{cldnn::format::fs_b_yx_fsv32, 5, cldnn::format::any},
{cldnn::format::nv12, 5, cldnn::format::any},
{cldnn::format::oiyx, 5, cldnn::format::any},
}),
format_adjust_test::PrintToString);

135
src/plugins/intel_gpu/tests/shape_infer/interpolate_si_test.cpp Normal file
View File

@@ -0,0 +1,135 @@
// Copyright (C) 2022 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include "test_utils.h"
#include <intel_gpu/primitives/input_layout.hpp>
#include <intel_gpu/primitives/resample.hpp>
#include <intel_gpu/primitives/data.hpp>
#include "resample_inst.h"
#include "program_wrapper.h"
#include <cmath>
#include <algorithm>
using namespace cldnn;
using namespace ::tests;
namespace shape_infer_tests {
using InterpolateOp = ov::op::v4::Interpolate;
struct InterpolateAttrs {
InterpolateAttrs(InterpolateOp::ShapeCalcMode shape_calc_mode) : shape_calc_mode(shape_calc_mode) {}
InterpolateOp::InterpolateMode mode = InterpolateOp::InterpolateMode::LINEAR;
InterpolateOp::ShapeCalcMode shape_calc_mode = InterpolateOp::ShapeCalcMode::SIZES;
std::vector<size_t> pads_begin;
std::vector<size_t> pads_end;
InterpolateOp::CoordinateTransformMode coordinate_transformation_mode = InterpolateOp::CoordinateTransformMode::HALF_PIXEL;
InterpolateOp::NearestMode nearest_mode = InterpolateOp::NearestMode::ROUND_PREFER_FLOOR;
bool antialias = false;
double cube_coeff = -0.75f;
};
struct interpolate_test_params {
layout in_layout;
layout pattern_layout;
std::vector<int64_t> pattern_data;
std::vector<float> scales;
std::vector<int64_t> axes;
InterpolateAttrs attrs;
layout expected_layout;
};
class interpolate_test_two_inputs : public testing::TestWithParam<interpolate_test_params> { };
TEST_P(interpolate_test_two_inputs, shape_infer) {
auto p = GetParam();
auto& engine = get_test_engine();
auto input_prim = std::make_shared<input_layout>("input", p.in_layout);
auto pattern_prim = std::make_shared<input_layout>("pattern", p.pattern_layout);
auto resample_prim = std::make_shared<resample>("output", "input", "pattern", p.scales, p.axes,
p.attrs.pads_begin, p.attrs.pads_end,
p.attrs.antialias, p.attrs.cube_coeff,
p.attrs.mode, p.attrs.shape_calc_mode,
p.attrs.coordinate_transformation_mode, p.attrs.nearest_mode);
cldnn::program prog(engine);
auto pattern_mem = engine.allocate_memory(p.pattern_layout);
set_values(pattern_mem, p.pattern_data);
auto& input_node = prog.get_or_create(input_prim);
auto& pattern_node = prog.get_or_create(pattern_prim);
auto& resample_node = prog.get_or_create(resample_prim);
program_wrapper::add_connection(prog, input_node, resample_node);
program_wrapper::add_connection(prog, pattern_node, resample_node);
auto params = resample_node.get_kernel_impl_params();
params->memory_deps = {{1, pattern_mem}};
auto res_w_data = resample_inst::calc_output_layouts<ov::PartialShape>(resample_node, *params);
ASSERT_EQ(res_w_data.size(), 1);
ASSERT_EQ(res_w_data[0], p.expected_layout);
}
INSTANTIATE_TEST_SUITE_P(smoke, interpolate_test_two_inputs,
testing::ValuesIn(std::vector<interpolate_test_params>{
{
layout{ov::PartialShape{1, 2, 48, 80}, data_types::f32, format::bfyx},
layout{ov::PartialShape{4}, data_types::i64, format::bfyx}, {-1, -1, -1, -1},
{0.5, 2.0}, {2, 3}, InterpolateAttrs{InterpolateOp::ShapeCalcMode::SCALES},
layout{ov::PartialShape{1, 2, 24, 160}, data_types::f32, format::bfyx}
},
{
layout{ov::PartialShape{2, 2, 3, 2}, data_types::f32, format::bfyx},
layout{ov::PartialShape{4}, data_types::i64, format::bfyx}, {2, 2, 2, 3},
{}, {}, InterpolateAttrs(InterpolateOp::ShapeCalcMode::SIZES),
layout{ov::PartialShape{2, 2, 2, 3}, data_types::f32, format::bfyx}
}
}));
class interpolate_test_single_input : public testing::TestWithParam<interpolate_test_params> { };
TEST_P(interpolate_test_single_input, shape_infer) {
auto p = GetParam();
auto& engine = get_test_engine();
auto input_prim = std::make_shared<input_layout>("input", p.in_layout);
auto resample_prim = std::make_shared<resample>("output", "input", p.pattern_data, p.scales, p.axes,
p.attrs.pads_begin, p.attrs.pads_end,
p.attrs.antialias, p.attrs.cube_coeff,
p.attrs.mode, p.attrs.shape_calc_mode,
p.attrs.coordinate_transformation_mode, p.attrs.nearest_mode);
cldnn::program prog(engine);
auto& input_node = prog.get_or_create(input_prim);
auto& resample_node = prog.get_or_create(resample_prim);
program_wrapper::add_connection(prog, input_node, resample_node);
auto params = resample_node.get_kernel_impl_params();
auto res = resample_inst::calc_output_layouts<ov::PartialShape>(resample_node, *params);
ASSERT_EQ(res.size(), 1);
ASSERT_EQ(res[0], p.expected_layout);
}
INSTANTIATE_TEST_SUITE_P(smoke, interpolate_test_single_input,
testing::ValuesIn(std::vector<interpolate_test_params>{
{
layout{ov::PartialShape{1, 2, 48, 80}, data_types::f32, format::bfyx},
layout{ov::PartialShape{4}, data_types::i64, format::bfyx}, {-1, -1, -1, -1},
{0.5, 2.0}, {2, 3}, InterpolateAttrs{InterpolateOp::ShapeCalcMode::SCALES},
layout{ov::PartialShape{1, 2, 24, 160}, data_types::f32, format::bfyx}
},
{
layout{ov::PartialShape{2, 2, 3, 2}, data_types::f32, format::bfyx},
layout{ov::PartialShape{4}, data_types::i64, format::bfyx}, {2, 2, 2, 3},
{}, {}, InterpolateAttrs(InterpolateOp::ShapeCalcMode::SIZES),
layout{ov::PartialShape{2, 2, 2, 3}, data_types::f32, format::bfyx}
}
}));
} // shape_infer_tests

116
src/plugins/intel_gpu/tests/test_cases/resample_gpu_test.cpp
View File

@@ -48,7 +48,7 @@ TEST(resample_gpu, basic_in2x3x2x2_nearest) {
12.f, 9.f, -17.f,
});
cldnn::network net {engine, topology };
cldnn::network net{ engine, topology };
net.set_input_data("input", input);
@@ -652,7 +652,7 @@ struct caffe_resample_random_test : testing::TestWithParam<caffe_resample_random
auto build_opts_opt = build_options();
build_opts_opt.set_option(build_option::outputs({"resample_opt"}));
build_opts.set_option(build_option::force_implementations({ {"resample_opt", {params.in_format, "resample_opt"}} }));
build_opts_opt.set_option(build_option::force_implementations({ {"resample_opt", {params.in_format, "resample_opt"}} }));
cldnn::network net_opt(engine, topo_opt, build_opts_opt);
@@ -726,6 +726,8 @@ TEST(resample_gpu, interpolate_in2x2x3x2_nearest1) {
// Sample Type: Nearest
auto& engine = get_test_engine();
cldnn::build_options options;
options.set_option(cldnn::build_option::allow_new_shape_infer(true));
int b = 2;
int f = 2;
@@ -734,7 +736,7 @@ TEST(resample_gpu, interpolate_in2x2x3x2_nearest1) {
tensor shape = tensor{batch(b), feature(f), spatial(x, y)};
auto input = engine.allocate_memory({ data_types::f32, format::bfyx, shape });
auto output_size = tensor(batch(b), feature(f), spatial(x*2, y*2));
std::vector<int64_t> output_pattern {b, f, y*2, x*2};
topology topology;
topology.add(input_layout("input", input->get_layout()));
@@ -744,7 +746,7 @@ TEST(resample_gpu, interpolate_in2x2x3x2_nearest1) {
auto ctm = resample::InterpolateOp::CoordinateTransformMode::HALF_PIXEL;
auto nm = resample::InterpolateOp::NearestMode::CEIL;
auto shapeCalcMode = resample::InterpolateOp::ShapeCalcMode::SIZES;
topology.add(resample("interpolate", "input", output_size, {}, {}, {0, 0, 0, 0}, {0, 0, 0, 0}, antialias, cube_coeff, mode, shapeCalcMode, ctm, nm));
topology.add(resample("interpolate", "input", output_pattern, {}, {}, {0, 0, 0, 0}, {0, 0, 0, 0}, antialias, cube_coeff, mode, shapeCalcMode, ctm, nm));
set_values(input, {
0.f, 1.f, 2.f,
@@ -757,7 +759,7 @@ TEST(resample_gpu, interpolate_in2x2x3x2_nearest1) {
21.f, 22.f, 23.f,
});
cldnn::network net {engine, topology };
cldnn::network net{ engine, topology, options };
net.set_input_data("input", input);
@@ -814,6 +816,8 @@ TEST(resample_gpu, interpolate_in2x2x3x2_nearest2) {
// Sample Type: Nearest
auto& engine = get_test_engine();
cldnn::build_options options;
options.set_option(cldnn::build_option::allow_new_shape_infer(true));
int b = 2;
int f = 2;
@@ -822,7 +826,7 @@ TEST(resample_gpu, interpolate_in2x2x3x2_nearest2) {
tensor shape = tensor{batch(b), feature(f), spatial(x, y)};
auto input = engine.allocate_memory({ data_types::f32, format::bfyx, shape });
auto output_size = tensor(batch(b), feature(f), spatial(x*2, y*2));
std::vector<int64_t> output_pattern {b, f, y*2, x*2};
topology topology;
topology.add(input_layout("input", input->get_layout()));
@@ -832,7 +836,7 @@ TEST(resample_gpu, interpolate_in2x2x3x2_nearest2) {
auto ctm = resample::InterpolateOp::CoordinateTransformMode::HALF_PIXEL;
auto nm = resample::InterpolateOp::NearestMode::ROUND_PREFER_FLOOR;
auto shapeCalcMode = resample::InterpolateOp::ShapeCalcMode::SIZES;
topology.add(resample("interpolate", "input", output_size, {}, {}, {0, 0, 0, 0}, {0, 0, 0, 0}, antialias, cube_coeff, mode, shapeCalcMode, ctm, nm));
topology.add(resample("interpolate", "input", output_pattern, {}, {}, {0, 0, 0, 0}, {0, 0, 0, 0}, antialias, cube_coeff, mode, shapeCalcMode, ctm, nm));
set_values(input, {
0.f, 1.f, 2.f,
@@ -845,7 +849,7 @@ TEST(resample_gpu, interpolate_in2x2x3x2_nearest2) {
21.f, 22.f, 23.f,
});
cldnn::network net {engine, topology };
cldnn::network net{ engine, topology, options };
net.set_input_data("input", input);
@@ -902,6 +906,8 @@ TEST(resample_gpu, interpolate_in2x2x3x2_nearest3) {
// Sample Type: Nearest
auto& engine = get_test_engine();
cldnn::build_options options;
options.set_option(cldnn::build_option::allow_new_shape_infer(true));
int b = 2;
int f = 2;
@@ -910,7 +916,7 @@ TEST(resample_gpu, interpolate_in2x2x3x2_nearest3) {
tensor shape = tensor{batch(b), feature(f), spatial(x, y)};
auto input = engine.allocate_memory({ data_types::f32, format::bfyx, shape });
auto output_size = tensor(batch(b), feature(f), spatial(x*2, y*2));
std::vector<int64_t> output_pattern {b, f, y*2, x*2};
topology topology;
topology.add(input_layout("input", input->get_layout()));
@@ -920,7 +926,7 @@ TEST(resample_gpu, interpolate_in2x2x3x2_nearest3) {
auto ctm = resample::InterpolateOp::CoordinateTransformMode::HALF_PIXEL;
auto nm = resample::InterpolateOp::NearestMode::ROUND_PREFER_CEIL;
auto shapeCalcMode = resample::InterpolateOp::ShapeCalcMode::SIZES;
topology.add(resample("interpolate", "input", output_size, {}, {}, {0, 0, 0, 0}, {0, 0, 0, 0}, antialias, cube_coeff, mode, shapeCalcMode, ctm, nm));
topology.add(resample("interpolate", "input", output_pattern, {}, {}, {0, 0, 0, 0}, {0, 0, 0, 0}, antialias, cube_coeff, mode, shapeCalcMode, ctm, nm));
set_values(input, {
0.f, 1.f, 2.f,
@@ -933,7 +939,7 @@ TEST(resample_gpu, interpolate_in2x2x3x2_nearest3) {
21.f, 22.f, 23.f,
});
cldnn::network net {engine, topology };
cldnn::network net{ engine, topology, options };
net.set_input_data("input", input);
@@ -990,6 +996,8 @@ TEST(resample_gpu, interpolate_in2x2x3x2_nearest4) {
// Sample Type: Nearest
auto& engine = get_test_engine();
cldnn::build_options options;
options.set_option(cldnn::build_option::allow_new_shape_infer(true));
int b = 2;
int f = 2;
@@ -998,7 +1006,7 @@ TEST(resample_gpu, interpolate_in2x2x3x2_nearest4) {
tensor shape = tensor{batch(b), feature(f), spatial(x, y)};
auto input = engine.allocate_memory({ data_types::f32, format::bfyx, shape });
auto output_size = tensor(batch(b), feature(f), spatial(x*2, y*2));
std::vector<int64_t> output_pattern {b, f, y*2, x*2};
topology topology;
topology.add(input_layout("input", input->get_layout()));
@@ -1008,7 +1016,7 @@ TEST(resample_gpu, interpolate_in2x2x3x2_nearest4) {
auto ctm = resample::InterpolateOp::CoordinateTransformMode::HALF_PIXEL;
auto nm = resample::InterpolateOp::NearestMode::FLOOR;
auto shapeCalcMode = resample::InterpolateOp::ShapeCalcMode::SIZES;
topology.add(resample("interpolate", "input", output_size, {}, {}, {0, 0, 0, 0}, {0, 0, 0, 0}, antialias, cube_coeff, mode, shapeCalcMode, ctm, nm));
topology.add(resample("interpolate", "input", output_pattern, {}, {}, {0, 0, 0, 0}, {0, 0, 0, 0}, antialias, cube_coeff, mode, shapeCalcMode, ctm, nm));
set_values(input, {
0.f, 1.f, 2.f,
@@ -1021,7 +1029,7 @@ TEST(resample_gpu, interpolate_in2x2x3x2_nearest4) {
21.f, 22.f, 23.f,
});
cldnn::network net {engine, topology };
cldnn::network net{ engine, topology, options };
net.set_input_data("input", input);
@@ -1078,6 +1086,8 @@ TEST(resample_gpu, interpolate_in2x2x3x2_nearest5) {
// Sample Type: Nearest
auto& engine = get_test_engine();
cldnn::build_options options;
options.set_option(cldnn::build_option::allow_new_shape_infer(true));
int b = 2;
int f = 2;
@@ -1086,7 +1096,7 @@ TEST(resample_gpu, interpolate_in2x2x3x2_nearest5) {
tensor shape = tensor{batch(b), feature(f), spatial(x, y)};
auto input = engine.allocate_memory({ data_types::f32, format::bfyx, shape });
auto output_size = tensor(batch(b), feature(f), spatial(x*2, y*2));
std::vector<int64_t> output_pattern {b, f, y*2, x*2};
topology topology;
topology.add(input_layout("input", input->get_layout()));
@@ -1096,7 +1106,7 @@ TEST(resample_gpu, interpolate_in2x2x3x2_nearest5) {
auto ctm = resample::InterpolateOp::CoordinateTransformMode::HALF_PIXEL;
auto nm = resample::InterpolateOp::NearestMode::SIMPLE;
auto shapeCalcMode = resample::InterpolateOp::ShapeCalcMode::SIZES;
topology.add(resample("interpolate", "input", output_size, {}, {}, {0, 0, 0, 0}, {0, 0, 0, 0}, antialias, cube_coeff, mode, shapeCalcMode, ctm, nm));
topology.add(resample("interpolate", "input", output_pattern, {}, {}, {0, 0, 0, 0}, {0, 0, 0, 0}, antialias, cube_coeff, mode, shapeCalcMode, ctm, nm));
set_values(input, {
0.f, 1.f, 2.f,
@@ -1109,7 +1119,7 @@ TEST(resample_gpu, interpolate_in2x2x3x2_nearest5) {
21.f, 22.f, 23.f,
});
cldnn::network net {engine, topology };
cldnn::network net{ engine, topology, options };
net.set_input_data("input", input);
@@ -1166,6 +1176,8 @@ TEST(resample_gpu, interpolate_in2x2x3x2_coord_transform_mode1) {
// Sample Type: Nearest
auto& engine = get_test_engine();
cldnn::build_options options;
options.set_option(cldnn::build_option::allow_new_shape_infer(true));
int b = 2;
int f = 2;
@@ -1176,7 +1188,7 @@ TEST(resample_gpu, interpolate_in2x2x3x2_coord_transform_mode1) {
y = 2;
x = 3;
auto output_size = tensor(batch(b), feature(f), spatial(x, y));
std::vector<int64_t> output_pattern {b, f, y, x};
topology topology;
topology.add(input_layout("input", input->get_layout()));
@@ -1186,7 +1198,7 @@ TEST(resample_gpu, interpolate_in2x2x3x2_coord_transform_mode1) {
auto ctm = resample::InterpolateOp::CoordinateTransformMode::HALF_PIXEL;
auto nm = resample::InterpolateOp::NearestMode::ROUND_PREFER_FLOOR;
auto shapeCalcMode = resample::InterpolateOp::ShapeCalcMode::SIZES;
topology.add(resample("interpolate", "input", output_size, {}, {}, {0, 0, 0, 0}, {0, 0, 0, 0}, antialias, cube_coeff, mode, shapeCalcMode, ctm, nm));
topology.add(resample("interpolate", "input", output_pattern, {}, {}, {0, 0, 0, 0}, {0, 0, 0, 0}, antialias, cube_coeff, mode, shapeCalcMode, ctm, nm));
set_values(input, {
0.f, 1.f, 2.f,
@@ -1199,7 +1211,7 @@ TEST(resample_gpu, interpolate_in2x2x3x2_coord_transform_mode1) {
21.f, 22.f, 23.f,
});
cldnn::network net {engine, topology };
cldnn::network net{ engine, topology, options };
net.set_input_data("input", input);
@@ -1234,6 +1246,8 @@ TEST(resample_gpu, interpolate_in2x2x3x2_coord_transform_mode2) {
// Sample Type: Nearest
auto& engine = get_test_engine();
cldnn::build_options options;
options.set_option(cldnn::build_option::allow_new_shape_infer(true));
int b = 2;
int f = 2;
@@ -1244,7 +1258,7 @@ TEST(resample_gpu, interpolate_in2x2x3x2_coord_transform_mode2) {
y = 1;
x = 3;
auto output_size = tensor(batch(b), feature(f), spatial(x, y));
std::vector<int64_t> output_pattern {b, f, y, x};
topology topology;
topology.add(input_layout("input", input->get_layout()));
@@ -1254,7 +1268,7 @@ TEST(resample_gpu, interpolate_in2x2x3x2_coord_transform_mode2) {
auto ctm = resample::InterpolateOp::CoordinateTransformMode::PYTORCH_HALF_PIXEL;
auto nm = resample::InterpolateOp::NearestMode::ROUND_PREFER_FLOOR;
auto shapeCalcMode = resample::InterpolateOp::ShapeCalcMode::SIZES;
topology.add(resample("interpolate", "input", output_size, {}, {}, {0, 0, 0, 0}, {0, 0, 0, 0}, antialias, cube_coeff, mode, shapeCalcMode, ctm, nm));
topology.add(resample("interpolate", "input", output_pattern, {}, {}, {0, 0, 0, 0}, {0, 0, 0, 0}, antialias, cube_coeff, mode, shapeCalcMode, ctm, nm));
set_values(input, {
0.f, 1.f, 2.f,
@@ -1267,7 +1281,7 @@ TEST(resample_gpu, interpolate_in2x2x3x2_coord_transform_mode2) {
21.f, 22.f, 23.f,
});
cldnn::network net {engine, topology };
cldnn::network net{ engine, topology, options };
net.set_input_data("input", input);
@@ -1296,6 +1310,8 @@ TEST(resample_gpu, interpolate_in2x2x3x2_coord_transform_mode3) {
// Sample Type: Nearest
auto& engine = get_test_engine();
cldnn::build_options options;
options.set_option(cldnn::build_option::allow_new_shape_infer(true));
int b = 2;
int f = 2;
@@ -1306,7 +1322,7 @@ TEST(resample_gpu, interpolate_in2x2x3x2_coord_transform_mode3) {
y = 2;
x = 3;
auto output_size = tensor(batch(b), feature(f), spatial(x, y));
std::vector<int64_t> output_pattern {b, f, y, x};
topology topology;
topology.add(input_layout("input", input->get_layout()));
@@ -1316,7 +1332,7 @@ TEST(resample_gpu, interpolate_in2x2x3x2_coord_transform_mode3) {
auto ctm = resample::InterpolateOp::CoordinateTransformMode::ASYMMETRIC;
auto nm = resample::InterpolateOp::NearestMode::ROUND_PREFER_FLOOR;
auto shapeCalcMode = resample::InterpolateOp::ShapeCalcMode::SIZES;
topology.add(resample("interpolate", "input", output_size, {}, {}, {0, 0, 0, 0}, {0, 0, 0, 0}, antialias, cube_coeff, mode, shapeCalcMode, ctm, nm));
topology.add(resample("interpolate", "input", output_pattern, {}, {}, {0, 0, 0, 0}, {0, 0, 0, 0}, antialias, cube_coeff, mode, shapeCalcMode, ctm, nm));
set_values(input, {
0.f, 1.f, 2.f,
@@ -1329,7 +1345,7 @@ TEST(resample_gpu, interpolate_in2x2x3x2_coord_transform_mode3) {
21.f, 22.f, 23.f,
});
cldnn::network net {engine, topology };
cldnn::network net{ engine, topology, options };
net.set_input_data("input", input);
@@ -1364,6 +1380,8 @@ TEST(resample_gpu, interpolate_in2x2x3x2_coord_transform_mode4) {
// Sample Type: Nearest
auto& engine = get_test_engine();
cldnn::build_options options;
options.set_option(cldnn::build_option::allow_new_shape_infer(true));
int b = 2;
int f = 2;
@@ -1374,7 +1392,7 @@ TEST(resample_gpu, interpolate_in2x2x3x2_coord_transform_mode4) {
y = 2;
x = 3;
auto output_size = tensor(batch(b), feature(f), spatial(x, y));
std::vector<int64_t> output_pattern {b, f, y, x};
topology topology;
topology.add(input_layout("input", input->get_layout()));
@@ -1384,7 +1402,7 @@ TEST(resample_gpu, interpolate_in2x2x3x2_coord_transform_mode4) {
auto ctm = resample::InterpolateOp::CoordinateTransformMode::TF_HALF_PIXEL_FOR_NN;
auto nm = resample::InterpolateOp::NearestMode::ROUND_PREFER_FLOOR;
auto shapeCalcMode = resample::InterpolateOp::ShapeCalcMode::SIZES;
topology.add(resample("interpolate", "input", output_size, {}, {}, {0, 0, 0, 0}, {0, 0, 0, 0}, antialias, cube_coeff, mode, shapeCalcMode, ctm, nm));
topology.add(resample("interpolate", "input", output_pattern, {}, {}, {0, 0, 0, 0}, {0, 0, 0, 0}, antialias, cube_coeff, mode, shapeCalcMode, ctm, nm));
set_values(input, {
0.f, 1.f, 2.f,
@@ -1397,7 +1415,7 @@ TEST(resample_gpu, interpolate_in2x2x3x2_coord_transform_mode4) {
21.f, 22.f, 23.f,
});
cldnn::network net {engine, topology };
cldnn::network net{ engine, topology, options };
net.set_input_data("input", input);
@@ -1432,6 +1450,8 @@ TEST(resample_gpu, interpolate_in2x2x3x2_coord_transform_mode5) {
// Sample Type: Nearest
auto& engine = get_test_engine();
cldnn::build_options options;
options.set_option(cldnn::build_option::allow_new_shape_infer(true));
int b = 2;
int f = 2;
@@ -1442,7 +1462,7 @@ TEST(resample_gpu, interpolate_in2x2x3x2_coord_transform_mode5) {
y = 2;
x = 3;
auto output_size = tensor(batch(b), feature(f), spatial(x, y));
std::vector<int64_t> output_pattern {b, f, y, x};
topology topology;
topology.add(input_layout("input", input->get_layout()));
@@ -1452,7 +1472,7 @@ TEST(resample_gpu, interpolate_in2x2x3x2_coord_transform_mode5) {
auto ctm = resample::InterpolateOp::CoordinateTransformMode::ALIGN_CORNERS;
auto nm = resample::InterpolateOp::NearestMode::ROUND_PREFER_FLOOR;
auto shapeCalcMode = resample::InterpolateOp::ShapeCalcMode::SIZES;
topology.add(resample("interpolate", "input", output_size, {}, {}, {0, 0, 0, 0}, {0, 0, 0, 0}, antialias, cube_coeff, mode, shapeCalcMode, ctm, nm));
topology.add(resample("interpolate", "input", output_pattern, {}, {}, {0, 0, 0, 0}, {0, 0, 0, 0}, antialias, cube_coeff, mode, shapeCalcMode, ctm, nm));
set_values(input, {
0.f, 1.f, 2.f,
@@ -1465,7 +1485,7 @@ TEST(resample_gpu, interpolate_in2x2x3x2_coord_transform_mode5) {
21.f, 22.f, 23.f,
});
cldnn::network net {engine, topology };
cldnn::network net{ engine, topology, options };
net.set_input_data("input", input);
@@ -1500,6 +1520,8 @@ TEST(resample_gpu, interpolate_in2x2x3x2_cubic) {
// Sample Type: Nearest
auto& engine = get_test_engine();
cldnn::build_options options;
options.set_option(cldnn::build_option::allow_new_shape_infer(true));
int b = 2;
int f = 2;
@@ -1510,7 +1532,7 @@ TEST(resample_gpu, interpolate_in2x2x3x2_cubic) {
y = 2;
x = 3;
auto output_size = tensor(batch(b), feature(f), spatial(x, y));
std::vector<int64_t> output_pattern {b, f, y, x};
topology topology;
topology.add(input_layout("input", input->get_layout()));
@@ -1518,7 +1540,7 @@ TEST(resample_gpu, interpolate_in2x2x3x2_cubic) {
float cube_coeff = -0.75f;
auto mode = resample::InterpolateOp::InterpolateMode::CUBIC;
auto shapeCalcMode = resample::InterpolateOp::ShapeCalcMode::SIZES;
topology.add(resample("interpolate", "input", output_size, {}, {}, {0, 0, 0, 0}, {0, 0, 0, 0}, antialias, cube_coeff, mode, shapeCalcMode));
topology.add(resample("interpolate", "input", output_pattern, {}, {}, {0, 0, 0, 0}, {0, 0, 0, 0}, antialias, cube_coeff, mode, shapeCalcMode));
set_values(input, {
0.f, 1.f, 2.f,
@@ -1531,7 +1553,7 @@ TEST(resample_gpu, interpolate_in2x2x3x2_cubic) {
21.f, 22.f, 23.f,
});
cldnn::network net {engine, topology };
cldnn::network net{ engine, topology, options };
net.set_input_data("input", input);
@@ -1566,6 +1588,8 @@ TEST(resample_gpu, interpolate_in2x2x3x2_cubic2) {
// Sample Type: Nearest
auto& engine = get_test_engine();
cldnn::build_options options;
options.set_option(cldnn::build_option::allow_new_shape_infer(true));
int b = 1;
int f = 1;
@@ -1575,7 +1599,7 @@ TEST(resample_gpu, interpolate_in2x2x3x2_cubic2) {
auto input = engine.allocate_memory({ data_types::f32, format::bfyx, shape });
x = 3;
auto output_size = tensor(batch(b), feature(f), spatial(x, y));
std::vector<int64_t> output_pattern {b, f, y, x};
topology topology;
topology.add(input_layout("input", input->get_layout()));
@@ -1583,14 +1607,14 @@ TEST(resample_gpu, interpolate_in2x2x3x2_cubic2) {
float cube_coeff = -0.75f;
auto mode = resample::InterpolateOp::InterpolateMode::CUBIC;
auto shapeCalcMode = resample::InterpolateOp::ShapeCalcMode::SIZES;
topology.add(resample("interpolate", "input", output_size, {}, {}, {0, 0, 0, 0}, {0, 0, 0, 0}, antialias, cube_coeff, mode, shapeCalcMode));
topology.add(resample("interpolate", "input", output_pattern, {}, {}, {0, 0, 0, 0}, {0, 0, 0, 0}, antialias, cube_coeff, mode, shapeCalcMode));
set_values(input, {
5.f, 1.f, 2.f,
3.f, 4.f, 5.f,
});
cldnn::network net {engine, topology };
cldnn::network net{ engine, topology, options };
net.set_input_data("input", input);
@@ -1617,6 +1641,8 @@ TEST(resample_gpu, interpolate_in2x2x3x2_linear) {
// Sample Type: Nearest
auto& engine = get_test_engine();
cldnn::build_options options;
options.set_option(cldnn::build_option::allow_new_shape_infer(true));
int b = 2;
int f = 2;
@@ -1627,7 +1653,7 @@ TEST(resample_gpu, interpolate_in2x2x3x2_linear) {
y = 2;
x = 3;
auto output_size = tensor(batch(b), feature(f), spatial(x, y));
std::vector<int64_t> output_pattern {b, f, y, x};
topology topology;
topology.add(input_layout("input", input->get_layout()));
@@ -1635,7 +1661,7 @@ TEST(resample_gpu, interpolate_in2x2x3x2_linear) {
float cube_coeff = -0.75f;
auto mode = resample::InterpolateOp::InterpolateMode::LINEAR;
auto shapeCalcMode = resample::InterpolateOp::ShapeCalcMode::SIZES;
topology.add(resample("interpolate", "input", output_size, {}, {}, {0, 0, 0, 0}, {0, 0, 0, 0}, antialias, cube_coeff, mode, shapeCalcMode));
topology.add(resample("interpolate", "input", output_pattern, {}, {}, {0, 0, 0, 0}, {0, 0, 0, 0}, antialias, cube_coeff, mode, shapeCalcMode));
set_values(input, {
0.f, 1.f, 2.f,
@@ -1648,7 +1674,7 @@ TEST(resample_gpu, interpolate_in2x2x3x2_linear) {
21.f, 22.f, 23.f,
});
cldnn::network net {engine, topology };
cldnn::network net{ engine, topology, options };
net.set_input_data("input", input);
@@ -1683,6 +1709,8 @@ TEST(resample_gpu, interpolate_in1x1x2x4_linear_scale) {
// Sample Type: Linear
auto& engine = get_test_engine();
cldnn::build_options options;
options.set_option(cldnn::build_option::allow_new_shape_infer(true));
int b = 1;
int f = 1;
@@ -1693,7 +1721,7 @@ TEST(resample_gpu, interpolate_in1x1x2x4_linear_scale) {
y = 1;
x = 2;
auto output_size = tensor(batch(b), feature(f), spatial(x, y));
std::vector<int64_t> output_pattern {b, f, y, x};
topology topology;
topology.add(input_layout("input", input->get_layout()));
@@ -1702,14 +1730,14 @@ TEST(resample_gpu, interpolate_in1x1x2x4_linear_scale) {
auto mode = resample::InterpolateOp::InterpolateMode::LINEAR;
auto shapeCalcMode = resample::InterpolateOp::ShapeCalcMode::SCALES;
topology.add(resample("interpolate", "input", output_size, {0.6f, 0.6f}, {2, 3}, {0, 0, 0, 0}, {0, 0, 0, 0}, antialias, cube_coeff, mode, shapeCalcMode));
topology.add(resample("interpolate", "input", output_pattern, {0.6f, 0.6f}, {2, 3}, {0, 0, 0, 0}, {0, 0, 0, 0}, antialias, cube_coeff, mode, shapeCalcMode));
set_values(input, {
1.f, 2.f, 3.f, 4.f,
5.f, 6.f, 7.f, 8.f,
});
cldnn::network net {engine, topology };
cldnn::network net{ engine, topology, options };
net.set_input_data("input", input);