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

clang format

Browse Source
This commit is contained in:
Mikhail Ryzhov 2023-04-18 17:56:54 +02:00
parent dad7151b37
commit 30dd9aef86
13 changed files with 280 additions and 282 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/plugins/intel_gna/src/frontend/layer_quantizer.cpp
View File

@ -8,7 +8,6 @@
#include "common/gna_target.hpp"
#include "gna_graph_tools.hpp"
#include "weights_converter.hpp"
#include "debug_new_pass.hpp" // DEBUG
namespace ov {
namespace intel_gna {

1
src/plugins/intel_gna/src/frontend/scale_factor_calc.cpp
View File

@ -11,7 +11,6 @@
#include "layers/gna_convolution_layer.hpp"
#include "log/debug.hpp"
#include "weights_converter.hpp"
#include "debug_new_pass.hpp" // DEBUG
namespace ov {
namespace intel_gna {

6
src/plugins/intel_gna/src/layers/gna_layer_type.hpp
View File

@ -95,9 +95,9 @@ static const InferenceEngine::details::caseless_map<std::string, LayerType> Laye
{"Pwl", LayerType::Pwl},
{"Identity", LayerType::Identity},
{"Gemm", LayerType::Gemm},
{"GNAConvolution", LayerType::GNAConvolution },
{"GNAMaxPool", LayerType::GNAMaxPool },
};
{"GNAConvolution", LayerType::GNAConvolution},
{"GNAMaxPool", LayerType::GNAMaxPool},
};
LayerType LayerTypeFromStr(const std::string& str);

118
src/plugins/intel_gna/src/ops/gna_convolution.cpp
View File

@ -4,14 +4,13 @@
#include "gna_convolution.hpp"
#include <cmath>
#include <cstddef>
#include <ngraph/validation_util.hpp>
#include "ngraph/attribute_visitor.hpp"
#include "ngraph/runtime/host_tensor.hpp"
#include <cmath>
#include <cstddef>
NGRAPH_RTTI_DEFINITION(ov::intel_gna::op::GNAConvolution, "GNAConvolution", 0);
namespace ov {
@ -29,16 +28,16 @@ int64_t calculate_num_spatial(const GNAConvolution* op,
const int64_t& num_non_spatial_filter_dims) {
int64_t num_spatial = op->m_num_spatial;
if (num_spatial == -1) {
const auto &input_rank = input_shape.rank();
const auto &filters_rank = filters_shape.rank();
const auto& input_rank = input_shape.rank();
const auto& filters_rank = filters_shape.rank();
if (const auto &size = op->m_dilations.size())
if (const auto& size = op->m_dilations.size())
num_spatial = static_cast<int64_t>(size);
if (const auto &size = op->m_strides.size())
if (const auto& size = op->m_strides.size())
num_spatial = static_cast<int64_t>(size);
if (const auto &size = op->m_pads_begin.size())
if (const auto& size = op->m_pads_begin.size())
num_spatial = static_cast<int64_t>(size);
if (const auto &size = op->m_pads_end.size())
if (const auto& size = op->m_pads_end.size())
num_spatial = static_cast<int64_t>(size);
if (input_rank.is_static())
num_spatial = input_rank.get_length() - num_non_spatial_data_dims;
@ -74,12 +73,12 @@ void update_and_validate_attributes(GNAConvolution* op) {
"Dilations should be defined for all and only spatial features.");
NODE_VALIDATION_CHECK(op,
static_cast<int64_t>(pad_begin.size()) == num_spatial &&
static_cast<int64_t>(pad_end.size()) == num_spatial,
static_cast<int64_t>(pad_end.size()) == num_spatial,
"Pads should be defined for all and only spatial features.");
NODE_VALIDATION_CHECK(op,
std::all_of(dilations.begin(),
dilations.end(),
[](const size_t &i) {
[](const size_t& i) {
return i > 0;
}),
"Filter dilation (",
@ -88,7 +87,7 @@ void update_and_validate_attributes(GNAConvolution* op) {
NODE_VALIDATION_CHECK(op,
std::all_of(strides.begin(),
strides.end(),
[](const size_t &i) {
[](const size_t& i) {
return i > 0;
}),
"Filter strides (",
@ -108,18 +107,18 @@ inline bool dynamic_check(const int64_t& num_spatial) {
}
// FIXME: do we need that function as a template ?
template<>
template <>
inline bool dynamic_check<ngraph::PartialShape>(const int64_t& num_spatial) {
return num_spatial != -1;
}
// FIXME: do we need that function as a template ?
// TODO: search where that function is used in openvino
template<class T>
template <class T>
bool resolve_auto_pad_for_shape(const GNAConvolution* op,
ngraph::CoordinateDiff& pads_begin,
ngraph::CoordinateDiff& pads_end,
const std::vector<T> &input_shapes,
const std::vector<T>& input_shapes,
const int64_t& num_non_spatial_data_dims,
const int64_t& num_non_spatial_filter_dims) {
const auto& auto_pad = op->get_auto_pad();
@ -181,17 +180,18 @@ bool resolve_auto_pad_for_shape(const GNAConvolution* op,
// FIXME: do we need that function as a template ?
// TODO: search where that function is used in openvino
template<class T>
template <class T>
void shape_infer(const GNAConvolution* op,
const ngraph::CoordinateDiff& pads_begin,
const ngraph::CoordinateDiff& pads_end,
const std::vector<T> &input_shapes,
std::vector<T> &output_shapes) {
const std::vector<T>& input_shapes,
std::vector<T>& output_shapes) {
NODE_VALIDATION_CHECK(op, input_shapes.size() == 2 && output_shapes.size() == 1);
auto input_shape = input_shapes[0], filters_shape = input_shapes[1];
const auto& num_spatial = op->m_num_spatial;
NODE_VALIDATION_CHECK(op, num_spatial != -1,
NODE_VALIDATION_CHECK(op,
num_spatial != -1,
"Convolution shape_infer should be provided with correct num_spatial attribute");
if (input_shape.rank().is_dynamic())
@ -201,7 +201,7 @@ void shape_infer(const GNAConvolution* op,
NODE_VALIDATION_CHECK(op,
(static_cast<int64_t>(input_shape.size()) == (num_spatial + 2)) &&
(static_cast<int64_t>(filters_shape.size()) == (num_spatial + 2)),
(static_cast<int64_t>(filters_shape.size()) == (num_spatial + 2)),
"Data batch and filters rank do not match (data batch shape: ",
input_shape,
", filters shape: ",
@ -213,20 +213,20 @@ void shape_infer(const GNAConvolution* op,
output_shape.resize(num_spatial + 2);
output_shape[0] = input_shape[0];
// Channel is the last in NHWC layout
*(output_shape.rbegin()) = filters_shape[0]; // NHWC C is last instead of filters_shape[0] for NCHW layout
*(output_shape.rbegin()) = filters_shape[0]; // NHWC C is last instead of filters_shape[0] for NCHW layout
const auto n_data_channel = *(input_shape.rbegin());
const auto n_filter_channel = *(filters_shape.rbegin());
NODE_VALIDATION_CHECK(
op,
n_data_channel.compatible(n_filter_channel), // instead of input_shape[1].compatible(filters_shape[1]),
"Data batch channel count (",
n_data_channel, // instead of input_shape[1],
") does not match filter input ",
"channel count (",
n_filter_channel, // instead of filters_shape[1],
").");
op,
n_data_channel.compatible(n_filter_channel), // instead of input_shape[1].compatible(filters_shape[1]),
"Data batch channel count (",
n_data_channel, // instead of input_shape[1],
") does not match filter input ",
"channel count (",
n_filter_channel, // instead of filters_shape[1],
").");
const auto& dilations = op->m_dilations;
const auto& strides = op->m_strides;
@ -259,16 +259,16 @@ void shape_infer(const GNAConvolution* op,
}
}
} // namespace internal
} // namespace internal
GNAConvolution::GNAConvolution(const ngraph::Output<Node>& data_batch,
const ngraph::Output<Node>& filters,
const ngraph::Output<Node>& bias,
const ngraph::Strides& strides,
const ngraph::CoordinateDiff& pads_begin,
const ngraph::CoordinateDiff& pads_end,
const ngraph::Strides& dilations,
const ov::op::PadType& auto_pad)
const ngraph::Output<Node>& filters,
const ngraph::Output<Node>& bias,
const ngraph::Strides& strides,
const ngraph::CoordinateDiff& pads_begin,
const ngraph::CoordinateDiff& pads_end,
const ngraph::Strides& dilations,
const ov::op::PadType& auto_pad)
: ov::op::Op({data_batch, filters, bias}),
m_strides(strides),
m_dilations(dilations),
@ -279,12 +279,12 @@ GNAConvolution::GNAConvolution(const ngraph::Output<Node>& data_batch,
}
GNAConvolution::GNAConvolution(const ngraph::Output<Node>& data_batch,
const ngraph::Output<Node>& filters,
const ngraph::Strides& strides,
const ngraph::CoordinateDiff& pads_begin,
const ngraph::CoordinateDiff& pads_end,
const ngraph::Strides& dilations,
const ov::op::PadType& auto_pad)
const ngraph::Output<Node>& filters,
const ngraph::Strides& strides,
const ngraph::CoordinateDiff& pads_begin,
const ngraph::CoordinateDiff& pads_end,
const ngraph::Strides& dilations,
const ov::op::PadType& auto_pad)
: ov::op::Op({data_batch, filters}),
m_strides(strides),
m_dilations(dilations),
@ -340,25 +340,25 @@ void GNAConvolution::validate_and_infer_types() {
std::shared_ptr<ngraph::Node> GNAConvolution::clone_with_new_inputs(const ngraph::OutputVector& new_args) const {
if (new_args.size() == 2) {
return std::make_shared<GNAConvolution>(new_args.at(0),
new_args.at(1),
m_strides,
m_pads_begin,
m_pads_end,
m_dilations,
m_auto_pad);
new_args.at(1),
m_strides,
m_pads_begin,
m_pads_end,
m_dilations,
m_auto_pad);
} else if (new_args.size() == 3) {
return std::make_shared<GNAConvolution>(new_args.at(0),
new_args.at(1),
new_args.at(2),
m_strides,
m_pads_begin,
m_pads_end,
m_dilations,
m_auto_pad);
new_args.at(1),
new_args.at(2),
m_strides,
m_pads_begin,
m_pads_end,
m_dilations,
m_auto_pad);
}
throw ngraph::ngraph_error("Unsupported number of arguments for GNAConvolution operation");
}
} // namespace op
} // namespace intel_gna
} // namespace ov
} // namespace op
} // namespace intel_gna
} // namespace ov

114
src/plugins/intel_gna/src/ops/gna_convolution.hpp
View File

@ -4,12 +4,12 @@
#pragma once
#include "openvino/op/op.hpp"
#include "ngraph/node.hpp"
#include <transformations_visibility.hpp>
#include "ngraph/coordinate_diff.hpp"
#include "ngraph/node.hpp"
#include "ngraph/op/op.hpp"
#include "openvino/op/op.hpp"
namespace ov {
namespace intel_gna {
@ -19,43 +19,35 @@ class GNAConvolution;
namespace internal {
int64_t calculate_num_spatial(const ov::intel_gna::op::GNAConvolution * op,
const ngraph::PartialShape& input_shape,
const ngraph::PartialShape& filters_shape,
const int64_t& num_non_spatial_data_dims,
const int64_t& num_non_spatial_filter_dims);
int64_t calculate_num_spatial(const ov::intel_gna::op::GNAConvolution* op,
const ngraph::PartialShape& input_shape,
const ngraph::PartialShape& filters_shape,
const int64_t& num_non_spatial_data_dims,
const int64_t& num_non_spatial_filter_dims);
void update_and_validate_attributes(ov::intel_gna::op::GNAConvolution* op);
template <class T>
bool resolve_auto_pad_for_shape(const ov::intel_gna::op::GNAConvolution* op,
ngraph::CoordinateDiff& pads_begin,
ngraph::CoordinateDiff& pads_end,
const std::vector<T>& input_shapes,
const int64_t& num_non_spatial_data_dims,
const int64_t& num_non_spatial_filter_dims);
ngraph::CoordinateDiff& pads_begin,
ngraph::CoordinateDiff& pads_end,
const std::vector<T>& input_shapes,
const int64_t& num_non_spatial_data_dims,
const int64_t& num_non_spatial_filter_dims);
template <class T>
void shape_infer(const ov::intel_gna::op::GNAConvolution* op,
const ngraph::CoordinateDiff& pads_begin,
const ngraph::CoordinateDiff& pads_end,
const std::vector<T>& input_shapes,
std::vector<T>& output_shapes);
const ngraph::CoordinateDiff& pads_begin,
const ngraph::CoordinateDiff& pads_end,
const std::vector<T>& input_shapes,
std::vector<T>& output_shapes);
} // namespace internal
} // namespace internal
/**
* @brief Activation modes for fused convolutions.
*
*/
enum class ActivationType { SIGMOID,
RELU,
TANH,
ABS,
LOG,
EXP,
SIGN,
CLAMP,
NO_ACTIVATION };
enum class ActivationType { SIGMOID, RELU, TANH, ABS, LOG, EXP, SIGN, CLAMP, NO_ACTIVATION };
/// \brief Convolution with NHWC layout
///
@ -85,21 +77,21 @@ public:
/// Output `[N, C_OUT, R1, ... Rf]`
///
GNAConvolution(const ngraph::Output<ngraph::Node>& data_batch,
const ngraph::Output<ngraph::Node>& filters,
const ngraph::Output<ngraph::Node>& bias,
const ngraph::Strides& strides,
const ngraph::CoordinateDiff& pads_begin,
const ngraph::CoordinateDiff& pads_end,
const ngraph::Strides& dilations,
const ov::op::PadType& auto_pad = ov::op::PadType::EXPLICIT);
const ngraph::Output<ngraph::Node>& filters,
const ngraph::Output<ngraph::Node>& bias,
const ngraph::Strides& strides,
const ngraph::CoordinateDiff& pads_begin,
const ngraph::CoordinateDiff& pads_end,
const ngraph::Strides& dilations,
const ov::op::PadType& auto_pad = ov::op::PadType::EXPLICIT);
GNAConvolution(const ngraph::Output<ngraph::Node>& data_batch,
const ngraph::Output<ngraph::Node>& filters,
const ngraph::Strides& strides,
const ngraph::CoordinateDiff& pads_begin,
const ngraph::CoordinateDiff& pads_end,
const ngraph::Strides& dilations,
const ov::op::PadType& auto_pad = ov::op::PadType::EXPLICIT);
const ngraph::Output<ngraph::Node>& filters,
const ngraph::Strides& strides,
const ngraph::CoordinateDiff& pads_begin,
const ngraph::CoordinateDiff& pads_end,
const ngraph::Strides& dilations,
const ov::op::PadType& auto_pad = ov::op::PadType::EXPLICIT);
void validate_and_infer_types() override;
bool visit_attributes(ov::AttributeVisitor& visitor) override;
@ -141,9 +133,15 @@ public:
void set_auto_pad(const ov::op::PadType& auto_pad) {
m_auto_pad = auto_pad;
}
bool has_add_node() const { return m_has_add_node; }
ActivationType get_activation() const { return m_activation_type; }
void set_activation(ActivationType activation_type) { m_activation_type = activation_type; }
bool has_add_node() const {
return m_has_add_node;
}
ActivationType get_activation() const {
return m_activation_type;
}
void set_activation(ActivationType activation_type) {
m_activation_type = activation_type;
}
/*
* TODO: for unit tests
@ -163,29 +161,29 @@ protected:
private:
friend int64_t internal::calculate_num_spatial(const ov::intel_gna::op::GNAConvolution* op,
const ngraph::PartialShape& input_shape,
const ngraph::PartialShape& filters_shape,
const int64_t& num_non_spatial_data_dims,
const int64_t& num_non_spatial_filter_dims);
const ngraph::PartialShape& input_shape,
const ngraph::PartialShape& filters_shape,
const int64_t& num_non_spatial_data_dims,
const int64_t& num_non_spatial_filter_dims);
friend void internal::update_and_validate_attributes(ov::intel_gna::op::GNAConvolution* op);
template <class T>
friend bool internal::resolve_auto_pad_for_shape(const ov::intel_gna::op::GNAConvolution* op,
ngraph::CoordinateDiff& pads_begin,
ngraph::CoordinateDiff& pads_end,
const std::vector<T>& input_shapes,
const int64_t& num_non_spatial_data_dims,
const int64_t& num_non_spatial_filter_dims);
ngraph::CoordinateDiff& pads_begin,
ngraph::CoordinateDiff& pads_end,
const std::vector<T>& input_shapes,
const int64_t& num_non_spatial_data_dims,
const int64_t& num_non_spatial_filter_dims);
template <class T>
friend void internal::shape_infer(const ov::intel_gna::op::GNAConvolution* op,
const ngraph::CoordinateDiff& pads_begin,
const ngraph::CoordinateDiff& pads_end,
const std::vector<T>& input_shapes,
std::vector<T>& output_shapes);
const ngraph::CoordinateDiff& pads_begin,
const ngraph::CoordinateDiff& pads_end,
const std::vector<T>& input_shapes,
std::vector<T>& output_shapes);
bool m_has_add_node;
ActivationType m_activation_type;
};
} // namespace op
} // namespace intel_gna
} // namespace ov
} // namespace op
} // namespace intel_gna
} // namespace ov

122
src/plugins/intel_gna/src/ops/gna_max_pool.cpp
View File

@ -3,14 +3,14 @@
//
#include "gna_max_pool.hpp"
#include <assert.h>
#include "ngraph/attribute_visitor.hpp"
#include "ngraph/node.hpp"
#include "ngraph/op/constant.hpp"
#include "ngraph/runtime/host_tensor.hpp"
#include "ngraph/validation_util.hpp"
#include "ngraph/node.hpp"
#include "ngraph/validation_util.hpp"
NGRAPH_RTTI_DEFINITION(ov::intel_gna::op::GNAMaxPool, "GNAMaxPool", 0);
@ -21,27 +21,27 @@ namespace op {
// Infers the output batch shape and element type for batched pooling fprop.
//
ov::PartialShape infer_batched_pooling_forward(const ngraph::Node* node,
const ov::PartialShape& data_batch_shape,
const ov::CoordinateDiff& data_padding_below,
const ov::CoordinateDiff& data_padding_above,
const ov::PartialShape& window_shape,
const ngraph::Strides& window_strides,
bool is_window_all_in_padding_allowed,
bool ceil_mode,
const ngraph::Strides& window_dilation);
const ov::PartialShape& data_batch_shape,
const ov::CoordinateDiff& data_padding_below,
const ov::CoordinateDiff& data_padding_above,
const ov::PartialShape& window_shape,
const ngraph::Strides& window_strides,
bool is_window_all_in_padding_allowed,
bool ceil_mode,
const ngraph::Strides& window_dilation);
//
// Infers the output batch shape and element type for batched pooling fprop.
//
ov::PartialShape infer_batched_pooling_forward(const ngraph::Node* node,
const ov::PartialShape& data_batch_shape,
const ov::CoordinateDiff& data_padding_below,
const ov::CoordinateDiff& data_padding_above,
const ov::PartialShape& window_shape,
const ngraph::Strides& window_strides,
bool is_window_all_in_padding_allowed,
bool ceil_mode,
const ngraph::Strides& window_dilation) {
const ov::PartialShape& data_batch_shape,
const ov::CoordinateDiff& data_padding_below,
const ov::CoordinateDiff& data_padding_above,
const ov::PartialShape& window_shape,
const ngraph::Strides& window_strides,
bool is_window_all_in_padding_allowed,
bool ceil_mode,
const ngraph::Strides& window_dilation) {
NODE_VALIDATION_CHECK(node,
data_batch_shape.rank().is_dynamic() ||
(data_batch_shape.rank().get_length() >= 3 && data_batch_shape.rank().get_length() <= 5),
@ -79,10 +79,12 @@ ov::PartialShape infer_batched_pooling_forward(const ngraph::Node* node,
if (data_batch_shape.rank().is_static()) {
batch_size = data_batch_shape[0];
channel_count = *(data_batch_shape.end() - 1); // EMUTEX fix NCHW -> NHWC from data_batch_shape[1]
channel_count = *(data_batch_shape.end() - 1); // EMUTEX fix NCHW -> NHWC from data_batch_shape[1]
for (int64_t i = 0; i < data_spatial_shape.rank().get_length(); i++) {
data_spatial_shape[i] = data_batch_shape[i + 1]; // EMUTEX fix NCHW -> NHWC from data_spatial_shape[i] = data_batch_shape[i + 2]
data_spatial_shape[i] =
data_batch_shape[i +
1]; // EMUTEX fix NCHW -> NHWC from data_spatial_shape[i] = data_batch_shape[i + 2]
}
NODE_VALIDATION_CHECK(node, batch_size.is_dynamic() || batch_size.get_length() > 0, "Batch size is zero.");
@ -101,36 +103,38 @@ ov::PartialShape infer_batched_pooling_forward(const ngraph::Node* node,
}
data_output_spatial_shape = ngraph::infer_windowed_reduction_output_shape(node,
data_spatial_shape,
data_dilation,
data_padding_below,
data_padding_above,
window_shape,
window_strides,
dilations,
is_window_all_in_padding_allowed,
ceil_mode);
data_spatial_shape,
data_dilation,
data_padding_below,
data_padding_above,
window_shape,
window_strides,
dilations,
is_window_all_in_padding_allowed,
ceil_mode);
}
ov::PartialShape data_batch_output_shape{ov::PartialShape::dynamic(data_output_spatial_shape.rank() + 2)};
data_batch_output_shape[0] = batch_size;
*(data_batch_output_shape.end() - 1) = channel_count;// EMUTEX fix NCHW -> NHWC data_batch_output_shape[1] = channel_count;
*(data_batch_output_shape.end() - 1) =
channel_count; // EMUTEX fix NCHW -> NHWC data_batch_output_shape[1] = channel_count;
for (int64_t i = 0; i < data_spatial_shape.rank().get_length(); i++) {
data_batch_output_shape[i + 1] = data_output_spatial_shape[i]; // EMUTEX fix NCHW -> NHWC data_batch_output_shape[i + 2] = data_output_spatial_shape[i];
data_batch_output_shape[i + 1] =
data_output_spatial_shape[i]; // EMUTEX fix NCHW -> NHWC data_batch_output_shape[i + 2] =
// data_output_spatial_shape[i];
}
return data_batch_output_shape;
}
GNAMaxPool::GNAMaxPool(const ngraph::Output<ngraph::Node>& arg,
const ngraph::Strides& strides,
const ov::Shape& pads_begin,
const ov::Shape& pads_end,
const ov::Shape& kernel,
const ov::op::RoundingType rounding_type,
const ov::op::PadType auto_pad)
const ngraph::Strides& strides,
const ov::Shape& pads_begin,
const ov::Shape& pads_end,
const ov::Shape& kernel,
const ov::op::RoundingType rounding_type,
const ov::op::PadType auto_pad)
: Op({arg}),
m_kernel(kernel),
m_strides(strides),
@ -216,21 +220,21 @@ ov::PartialShape GNAMaxPool::infer_output_shape(const ngraph::Strides& dilations
ov::CoordinateDiff pads_begin(m_pads_begin.begin(), m_pads_begin.end());
ov::CoordinateDiff pads_end(m_pads_end.begin(), m_pads_end.end());
output_shape = ov::intel_gna::op::infer_batched_pooling_forward(this,
get_input_partial_shape(0),
pads_begin,
pads_end,
m_kernel,
m_strides,
true,
m_rounding_type == ov::op::RoundingType::CEIL,
dilations);
get_input_partial_shape(0),
pads_begin,
pads_end,
m_kernel,
m_strides,
true,
m_rounding_type == ov::op::RoundingType::CEIL,
dilations);
} else {
if (arg_shape.rank().is_static()) {
output_shape = std::vector<ov::Dimension>(arg_shape.rank().get_max_length(), ov::Dimension::dynamic());
if (arg_shape[0].is_static()) {
output_shape[0] = arg_shape[0]; // batch size
}
if ((arg_shape.end() - 1)->is_static()) { // EMUTEX FIXED: from [1] to end() - 1 NCHW -> NHWC
if ((arg_shape.end() - 1)->is_static()) { // EMUTEX FIXED: from [1] to end() - 1 NCHW -> NHWC
*(output_shape.end() - 1) = *(arg_shape.end() - 1); // channel size
}
}
@ -240,9 +244,9 @@ ov::PartialShape GNAMaxPool::infer_output_shape(const ngraph::Strides& dilations
}
bool GNAMaxPool::update_auto_padding(const ov::PartialShape& in_shape,
const ngraph::Strides& filter_dilations,
ov::Shape& new_pads_end,
ov::Shape& new_pads_begin) const {
const ngraph::Strides& filter_dilations,
ov::Shape& new_pads_end,
ov::Shape& new_pads_begin) const {
bool update_auto_padding_succeed = true;
if (m_auto_pad == ov::op::PadType::SAME_UPPER || m_auto_pad == ov::op::PadType::SAME_LOWER) {
ov::CoordinateDiff pads_end, pads_begin;
@ -262,14 +266,14 @@ bool GNAMaxPool::update_auto_padding(const ov::PartialShape& in_shape,
std::shared_ptr<ngraph::Node> GNAMaxPool::clone_with_new_inputs(const ov::OutputVector& new_args) const {
check_new_args_count(this, new_args);
return std::make_shared<GNAMaxPool>(new_args.at(0),
m_strides,
m_pads_begin,
m_pads_end,
m_kernel,
m_rounding_type,
m_auto_pad);
m_strides,
m_pads_begin,
m_pads_end,
m_kernel,
m_rounding_type,
m_auto_pad);
}
} // namespace op
} // namespace intel_gna
} // namespace ov
} // namespace op
} // namespace intel_gna
} // namespace ov

20
src/plugins/intel_gna/src/ops/gna_max_pool.hpp
View File

@ -6,9 +6,9 @@
#include <limits>
#include "ngraph/node.hpp"
#include "openvino/op/op.hpp"
#include "openvino/op/util/attr_types.hpp"
#include "ngraph/node.hpp"
#include "openvino/op/util/max_pool_base.hpp"
namespace ov {
@ -33,12 +33,12 @@ public:
/// computing output shape.
/// \param auto_pad The pad type for automatically computing padding sizes.
GNAMaxPool(const ngraph::Output<ngraph::Node>& arg,
const ngraph::Strides& strides,
const ngraph::Shape& pads_begin,
const ngraph::Shape& pads_end,
const ngraph::Shape& kernel,
const ov::op::RoundingType rounding_type = ov::op::RoundingType::FLOOR,
const ov::op::PadType auto_pad = ov::op::PadType::EXPLICIT);
const ngraph::Strides& strides,
const ngraph::Shape& pads_begin,
const ngraph::Shape& pads_end,
const ngraph::Shape& kernel,
const ov::op::RoundingType rounding_type = ov::op::RoundingType::FLOOR,
const ov::op::PadType auto_pad = ov::op::PadType::EXPLICIT);
void validate_and_infer_types() override;
bool visit_attributes(ov::AttributeVisitor& visitor) override;
@ -103,6 +103,6 @@ protected:
ov::op::PadType m_auto_pad;
ov::op::RoundingType m_rounding_type;
};
} // namespace op
} // namespace intel_gna
} // namespace ov
} // namespace op
} // namespace intel_gna
} // namespace ov

90
src/plugins/intel_gna/src/transformations/fuse_conv_biasadd_activation.cpp
View File

@ -1,14 +1,14 @@
// Copyright (C) 2018-2023 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include <type_traits>
#include <utility>
#include <memory>
#include "openvino/cc/ngraph/itt.hpp"
#include "fuse_conv_biasadd_activation.hpp"
#include <memory>
#include <type_traits>
#include <utility>
#include "exec_graph_info.hpp"
#include "openvino/cc/ngraph/itt.hpp"
#include "openvino/core/graph_util.hpp"
#include "openvino/core/node.hpp"
#include "openvino/core/node_output.hpp"
@ -16,15 +16,15 @@
#include "openvino/core/shape.hpp"
#include "openvino/core/type/element_type.hpp"
#include "openvino/opsets/opset1.hpp"
#include "openvino/pass/pattern/matcher.hpp"
#include "openvino/pass/pattern/op/or.hpp"
#include "openvino/pass/pattern/op/label.hpp"
#include "openvino/pass/pattern/op/pattern.hpp"
#include "openvino/opsets/opset10.hpp"
#include "openvino/pass/manager.hpp"
#include "openvino/pass/pattern/matcher.hpp"
#include "openvino/pass/pattern/op/label.hpp"
#include "openvino/pass/pattern/op/or.hpp"
#include "openvino/pass/pattern/op/pattern.hpp"
#include "openvino/pass/pattern/op/wrap_type.hpp"
#include "ops/gna_convolution.hpp"
#include "rt_info/gna_node_id.hpp"
#include "openvino/opsets/opset10.hpp"
using namespace ov::pass::pattern;
using namespace ov::intel_gna::op;
@ -50,7 +50,7 @@ std::pair<std::shared_ptr<A>, std::shared_ptr<B>> parse_eltwise_inputs(std::shar
}
struct GnaConvCallbacks {
static bool gna_convolution_with_biasadd(Matcher &m) {
static bool gna_convolution_with_biasadd(Matcher& m) {
auto eltwise = m.get_match_root();
auto m_conv_const_pair = parse_eltwise_inputs<GNAConvolution, Constant>(eltwise);
auto m_conv = m_conv_const_pair.first;
@ -68,24 +68,25 @@ struct GnaConvCallbacks {
return false;
}
const ov::Output<ov::Node> &data = m_conv->input(0).get_source_output();
const ov::Output<ov::Node> &filters = m_conv->input(1).get_source_output();
const ov::Output<ov::Node> &bias = m_const->output(0);
const ov::Output<ov::Node>& data = m_conv->input(0).get_source_output();
const ov::Output<ov::Node>& filters = m_conv->input(1).get_source_output();
const ov::Output<ov::Node>& bias = m_const->output(0);
auto gna_conv = std::make_shared<GNAConvolution>(data,
filters,
bias,
m_conv->get_strides(),
m_conv->get_pads_begin(),
m_conv->get_pads_end(),
m_conv->get_dilations(),
m_conv->get_auto_pad());
filters,
bias,
m_conv->get_strides(),
m_conv->get_pads_begin(),
m_conv->get_pads_end(),
m_conv->get_dilations(),
m_conv->get_auto_pad());
ov::Output<ov::Node> new_conv(gna_conv);
gna_conv->set_friendly_name(eltwise->get_friendly_name());
ov::copy_runtime_info({m_conv, eltwise}, new_conv.get_node_shared_ptr());
ov::intel_gna::rt_info::set_node_id(new_conv.get_node_shared_ptr(), ov::intel_gna::rt_info::get_node_id(eltwise));
ov::intel_gna::rt_info::set_node_id(new_conv.get_node_shared_ptr(),
ov::intel_gna::rt_info::get_node_id(eltwise));
const std::string originalLayers = eltwise->get_friendly_name() + "," + m_conv->get_friendly_name();
gna_conv->get_rt_info()[ExecGraphInfoSerialization::ORIGINAL_NAMES] = originalLayers;
@ -105,7 +106,8 @@ struct GnaConvCallbacks {
auto gna_conv1 = std::dynamic_pointer_cast<GNAConvolution>(input1);
auto can_be_fused = [](const std::shared_ptr<ov::Node>& target, const std::shared_ptr<ov::Node>& fused_input) {
return (target && fused_input && (get_node_id(target) > get_node_id(fused_input) || ov::op::util::is_constant(fused_input)));
return (target && fused_input &&
(get_node_id(target) > get_node_id(fused_input) || ov::op::util::is_constant(fused_input)));
};
if (gna_conv0 && gna_conv1) {
@ -126,7 +128,7 @@ struct GnaConvCallbacks {
return {nullptr, nullptr};
}
static bool sink_add_to_gna_convolution(Matcher &m) {
static bool sink_add_to_gna_convolution(Matcher& m) {
auto add = std::dynamic_pointer_cast<Add>(m.get_match_root());
auto gna_conv_node_pair = parse_gna_conv_inputs(m.get_match_root());
auto gna_conv = gna_conv_node_pair.first;
@ -140,9 +142,9 @@ struct GnaConvCallbacks {
return false;
}
const ov::Output<ov::Node> &data = gna_conv->input(0).get_source_output();
const ov::Output<ov::Node> &filters = gna_conv->input(1).get_source_output();
const ov::Output<ov::Node> &bias = gna_conv->input(2).get_source_output();
const ov::Output<ov::Node>& data = gna_conv->input(0).get_source_output();
const ov::Output<ov::Node>& filters = gna_conv->input(1).get_source_output();
const ov::Output<ov::Node>& bias = gna_conv->input(2).get_source_output();
auto gna_conv_add = std::make_shared<GNAConvolution>(data,
filters,
@ -158,9 +160,9 @@ struct GnaConvCallbacks {
ov::copy_runtime_info({node, gna_conv}, gna_conv_add);
set_node_id(gna_conv_add, get_node_id(add));
auto &rt_info = gna_conv->get_rt_info();
auto& rt_info = gna_conv->get_rt_info();
if (rt_info.count(ExecGraphInfoSerialization::ORIGINAL_NAMES) > 0) {
auto &rt_info_layer_names = rt_info[ExecGraphInfoSerialization::ORIGINAL_NAMES];
auto& rt_info_layer_names = rt_info[ExecGraphInfoSerialization::ORIGINAL_NAMES];
const auto original_names = rt_info_layer_names.template as<std::string>();
const std::string original_names_with_activation = add->get_friendly_name() + "," + original_names;
rt_info_layer_names = original_names_with_activation;
@ -172,7 +174,7 @@ struct GnaConvCallbacks {
return true;
}
static bool sink_activation_to_gna_convolution(Matcher &m) {
static bool sink_activation_to_gna_convolution(Matcher& m) {
auto activation_node = m.get_match_root();
auto gna_conv = std::dynamic_pointer_cast<GNAConvolution>(
activation_node->input(0).get_source_output().get_node_shared_ptr());
@ -203,9 +205,9 @@ struct GnaConvCallbacks {
gna_conv->set_friendly_name(activation_node->get_friendly_name());
set_node_id(gna_conv, get_node_id(activation_node));
auto &rt_info = gna_conv->get_rt_info();
auto& rt_info = gna_conv->get_rt_info();
if (rt_info.count(ExecGraphInfoSerialization::ORIGINAL_NAMES) > 0) {
auto &rt_info_layer_names = rt_info[ExecGraphInfoSerialization::ORIGINAL_NAMES];
auto& rt_info_layer_names = rt_info[ExecGraphInfoSerialization::ORIGINAL_NAMES];
const auto original_names = rt_info_layer_names.template as<std::string>();
const std::string original_names_with_activation =
activation_node->get_friendly_name() + "," + original_names;
@ -254,11 +256,13 @@ bool is_bias_to_be_fused(const ov::Output<ov::Node>& output) {
// NHWC or HWC
size_t bias_channel_index = bias_shape.size() - 1;
size_t conv_channel_index = conv_shape.size() - 1;
if (bias_shape.at(bias_channel_index) != conv_shape.at(conv_channel_index) && bias_shape.at(bias_channel_index) != 1 ) {
if (bias_shape.at(bias_channel_index) != conv_shape.at(conv_channel_index) &&
bias_shape.at(bias_channel_index) != 1) {
return false;
}
for (size_t i = 0; i < bias_shape.size(); i++) {
if ((i != bias_channel_index) && (bias_shape.at(i) != 1)) return false;
if ((i != bias_channel_index) && (bias_shape.at(i) != 1))
return false;
}
return true;
}
@ -283,7 +287,7 @@ bool is_add_to_be_fused(const ov::Output<ov::Node>& output) {
}
return (partial_shape0.to_shape() == partial_shape1.to_shape());
}
} // namespace
} // namespace
bool ov::intel_gna::pass::GnaFuseMarkUpNodesOrder::run_on_model(const std::shared_ptr<ov::Model>& m) {
RUN_ON_FUNCTION_SCOPE(GnaFuseMarkUpNodesOrder);
@ -308,7 +312,7 @@ ov::intel_gna::pass::FuseConvolutionWithBiasAdd::FuseConvolutionWithBiasAdd() {
auto bias = wrap_type<Constant>();
auto add = wrap_type<Add>({conv, bias}, is_bias_to_be_fused);
matcher_pass_callback callback = [](Matcher &m) {
matcher_pass_callback callback = [](Matcher& m) {
return GnaConvCallbacks::gna_convolution_with_biasadd(m);
};
@ -321,9 +325,9 @@ ov::intel_gna::pass::FuseConvolutionWithBiasAddAdd::FuseConvolutionWithBiasAddAd
auto gna_convolution = wrap_type<GNAConvolution>(consumers_count(1));
auto add1 = wrap_type<Add>({gna_convolution, any_input()}, is_add_to_be_fused);
auto add2 = wrap_type<Add>({any_input(), gna_convolution}, is_add_to_be_fused);
auto add = std::make_shared<::op::Or>(ov::OutputVector{ add1, add2 });
auto add = std::make_shared<::op::Or>(ov::OutputVector{add1, add2});
matcher_pass_callback callback = [](Matcher &m) {
matcher_pass_callback callback = [](Matcher& m) {
return GnaConvCallbacks::sink_add_to_gna_convolution(m);
};
@ -334,15 +338,9 @@ ov::intel_gna::pass::FuseConvolutionWithBiasAddAdd::FuseConvolutionWithBiasAddAd
ov::intel_gna::pass::SinkActivationToGnaConvolution::SinkActivationToGnaConvolution() {
MATCHER_SCOPE(SinkActivationToGnaConvolution);
auto gna_convolution = wrap_type<GNAConvolution>(consumers_count(1));
auto activation = wrap_type<Relu,
Sigmoid,
Tanh,
Abs,
Log,
Clamp,
Sign>({gna_convolution});
auto activation = wrap_type<Relu, Sigmoid, Tanh, Abs, Log, Clamp, Sign>({gna_convolution});
matcher_pass_callback callback = [](Matcher &m) {
matcher_pass_callback callback = [](Matcher& m) {
return GnaConvCallbacks::sink_activation_to_gna_convolution(m);
};

1
src/plugins/intel_gna/src/transformations/fuse_conv_biasadd_activation.hpp
View File

@ -5,6 +5,7 @@
#pragma once
#include <ngraph/node.hpp>
#include "openvino/pass/graph_rewrite.hpp"
namespace ov {

6
src/plugins/intel_gna/src/transformations/rt_info/gna_node_id.hpp
View File

@ -32,6 +32,6 @@ public:
return false;
}
};
} // namespace rt_info
} // namespace intel_gna
} // namespace ov
} // namespace rt_info
} // namespace intel_gna
} // namespace ov

74
src/plugins/intel_gna/src/transformations/transpose_nchw.cpp
View File

@ -2,21 +2,19 @@
// SPDX-License-Identifier: Apache-2.0
//
#include <openvino/cc/ngraph/itt.hpp>
#include "transformations/transpose_nchw.hpp"
#include "transformations/utils/transformation_helper.hpp"
#include <ngraph/opsets/opset8.hpp>
#include <ngraph/pass/manager.hpp>
#include <ngraph/pattern/op/wrap_type.hpp>
#include <transformations/utils/utils.hpp>
#include <openvino/cc/ngraph/itt.hpp>
#include <ops/gna_convolution.hpp>
#include <ops/gna_max_pool.hpp>
#include <ngraph/pass/manager.hpp>
#include <transformations/utils/utils.hpp>
#include <vector>
#include "transformations/utils/transformation_helper.hpp"
NGRAPH_RTTI_DEFINITION(ov::intel_gna::pass::TransposeNCHW, "TransposeNCHW", 0);
NGRAPH_RTTI_DEFINITION(ov::intel_gna::pass::SubstituteGNAConvolution, "SubstituteGNAConvolution", 0);
NGRAPH_RTTI_DEFINITION(ov::intel_gna::pass::SubstituteGNAMaxPool, "SubstituteGNAMaxPool", 0);
@ -32,7 +30,7 @@ ngraph::Shape MakeTransposeOrderNHWC2NCHW(size_t shape_size);
3D: NCX {0, 1, 2} -> NXC {0, 2, 1}
4D: NCHW {0, 1, 2, 3} -> NHWC {0, 2, 3, 1}
5D: NCZYX {0, 1, 2, 3, 4} -> NZYXC {0, 2, 3, 4, 1}
after convolution convert NHWC -> NCHW
3D: NXC {0, 1, 2} -> NCX {0, 2, 1}
4D: NHWC {0, 1, 2, 3} -> NCHW {0, 3, 1, 2}
@ -89,7 +87,7 @@ bool HasChildNode(Node node) {
return false;
}
} // namespace
} // namespace
namespace SubstituteGNAConvolutionNS {
@ -114,25 +112,25 @@ bool DoTransformation(Node convolution) {
ngraph::Shape{transpose_before_order.size()},
transpose_before_order);
auto transpose_before = std::make_shared<ngraph::opset8::Transpose>(convolution_input_data_node,
transpose_const);
auto transpose_before = std::make_shared<ngraph::opset8::Transpose>(convolution_input_data_node, transpose_const);
auto transpose_conv_constant = std::make_shared<ngraph::opset8::Transpose>(convolution_input_const_node,
transpose_const);
auto transpose_conv_constant =
std::make_shared<ngraph::opset8::Transpose>(convolution_input_const_node, transpose_const);
auto conv_new = std::make_shared<ov::intel_gna::op::GNAConvolution>(transpose_before,
transpose_conv_constant,
convolution_node->get_strides(),
convolution_node->get_pads_begin(),
convolution_node->get_pads_end(),
convolution_node->get_dilations(),
convolution_node->get_auto_pad());
transpose_conv_constant,
convolution_node->get_strides(),
convolution_node->get_pads_begin(),
convolution_node->get_pads_end(),
convolution_node->get_dilations(),
convolution_node->get_auto_pad());
const ngraph::Shape transpose_after_order = MakeTransposeOrderNHWC2NCHW(conv_new->get_output_shape(0).size());
auto transpose_after = std::make_shared<ngraph::opset8::Transpose>(conv_new,
ngraph::opset8::Constant::create(ngraph::element::i64,
ngraph::Shape{transpose_after_order.size()},
transpose_after_order));
auto transpose_after = std::make_shared<ngraph::opset8::Transpose>(
conv_new,
ngraph::opset8::Constant::create(ngraph::element::i64,
ngraph::Shape{transpose_after_order.size()},
transpose_after_order));
ov::copy_runtime_info(convolution_node, {transpose_before, transpose_const, conv_new, transpose_after});
@ -141,7 +139,7 @@ bool DoTransformation(Node convolution) {
return true;
}
} // namespace SubstituteGNAConvolutionNS
} // namespace SubstituteGNAConvolutionNS
namespace SubstituteGNAMaxPoolNS {
@ -158,23 +156,23 @@ bool DoTransformation(Node max_pool) {
ngraph::Shape{transpose_before_order.size()},
transpose_before_order);
auto transpose_before = std::make_shared<ngraph::opset8::Transpose>(max_pool_input_data_node,
transpose_const);
auto transpose_before = std::make_shared<ngraph::opset8::Transpose>(max_pool_input_data_node, transpose_const);
auto max_pool_new = std::make_shared<ov::intel_gna::op::GNAMaxPool>(transpose_before,
max_pool_node->get_strides(),
max_pool_node->get_pads_begin(),
max_pool_node->get_pads_end(),
max_pool_node->get_kernel(),
max_pool_node->get_rounding_type(),
max_pool_node->get_auto_pad());
max_pool_node->get_strides(),
max_pool_node->get_pads_begin(),
max_pool_node->get_pads_end(),
max_pool_node->get_kernel(),
max_pool_node->get_rounding_type(),
max_pool_node->get_auto_pad());
const ngraph::Shape transpose_after_order = MakeTransposeOrderNHWC2NCHW(max_pool_new->get_output_shape(0).size());
auto transpose_after = std::make_shared<ngraph::opset8::Transpose>(max_pool_new,
ngraph::opset8::Constant::create(ngraph::element::i64,
ngraph::Shape{transpose_after_order.size()},
transpose_after_order));
auto transpose_after = std::make_shared<ngraph::opset8::Transpose>(
max_pool_new,
ngraph::opset8::Constant::create(ngraph::element::i64,
ngraph::Shape{transpose_after_order.size()},
transpose_after_order));
ov::copy_runtime_info(max_pool_node, {transpose_before, transpose_const, max_pool_new, transpose_after});
@ -183,7 +181,7 @@ bool DoTransformation(Node max_pool) {
return true;
}
} // namespace SubstituteGNAMaxPoolNS
} // namespace SubstituteGNAMaxPoolNS
// ----------------------------------------------------------------------------
@ -231,5 +229,5 @@ bool ov::intel_gna::pass::TransposeNCHW::run_on_model(const std::shared_ptr<ngra
manager.register_pass<ov::intel_gna::pass::SubstituteGNAMaxPool>();
manager.run_passes(function);
return false; // FIXME: should we return true here?
return false; // FIXME: should we return true here?
}

8
src/plugins/intel_gna/src/transformations/transpose_nchw.hpp
View File

@ -28,9 +28,9 @@ public:
class TransposeNCHW : public ngraph::pass::FunctionPass {
public:
NGRAPH_RTTI_DECLARATION;
bool run_on_model(const std::shared_ptr<ngraph::Function>& f) override;
bool run_on_model(const std::shared_ptr<ngraph::Function>& f) override;
};
} // namespace pass
} // namespace intel_gna
} // namespace ov
} // namespace pass
} // namespace intel_gna
} // namespace ov

1
thirdparty/json/nlohmann_json_schema_validator vendored Submodule

@ -0,0 +1 @@
Subproject commit 27fc1d094503623dfe39365ba82581507524545c