From: Ivan Tikhonov Date: Fri, 4 Sep 2020 06:04:36 +0000 (+0300) Subject: LSTMCell/Sequence v1, reference implementations and decompose transformations for... X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=2f5a28d44f1fc8e866e587121ea88dd3f711dc8e;p=platform%2Fupstream%2Fdldt.git LSTMCell/Sequence v1, reference implementations and decompose transformations for LSTM/GRU/RNN Cells (#2000) * validate_and_infer_types() implementation * input parameter validation for LSTM, GRU and RNN * style-check applied * Add LSTMSequence dynamic shape validation and test props for RNNCell, GRUCell, LSTMCell and LSTMSequence. * recurrent_sequence.hpp moved to ngraph/core/include/ngraph/op/util/ * style check applied * removed unused variable from LSTMSequence::validate_and_infer_types * Add missing newline mark at the end of file. * Add supression macro for FusedOp deprecation. * Add element type initialization * transpose,rnn cell reference implementations * Apply PR review remarks * reference implementations for cells op, single layer tests, align lstm cell/sequence according to the spec * lstm/gru/rnn cell decompostion transformations * ngraph codestyle * clean up * ngraph code style * change inheritance of Cells, fix build * fix build * fix build again * remove Peepholes from LSTMSeq, fix copy_runtime_info in transformations * Rewrite tests to use gtest exception assertions. * resolve tests issues * ngraph codestyle * add missed files * fix typeprop tests * fix lstm sequence checks * fix arm build * fix arm again * delete unnecessary file * add convert weghts format function, enable lstm test, resolve review comments * add ngraph builders * ngraph codestyle * fix unit tests * revert transpose reference implementation * revert LSTM Cell v0, add LSTMCell v1, update transformation lstm_cell_to_cell_ie * v1 version of LSTMCell op * LSTMSequence v1 operation, exclude LSTMSeq from opset4 * fix python api tests * resolve review comments, tests for decomposition transformations, switch lstm cell to opset4 in mo Co-authored-by: Szymon Durawa --- diff --git a/inference-engine/src/legacy_api/src/convert_function_to_cnn_network.cpp b/inference-engine/src/legacy_api/src/convert_function_to_cnn_network.cpp index 498b73c..fe86357 100644 --- a/inference-engine/src/legacy_api/src/convert_function_to_cnn_network.cpp +++ b/inference-engine/src/legacy_api/src/convert_function_to_cnn_network.cpp @@ -410,6 +410,29 @@ InferenceEngine::details::CNNLayerCreator::CNNLayerCreator(const std::shared_ptr return res; }); + addSpecificCreator({"LSTMCellIE"}, [](const std::shared_ptr<::ngraph::Node>& node, + const std::map params) -> CNNLayerPtr { + LayerParams attrs = {node->get_friendly_name(), "LSTMCell", + details::convertPrecision(node->get_output_element_type(0))}; + auto res = std::make_shared(attrs); + res->params = params; + Builder::NodeConverter converter; + const auto weightsNode = node->input_value(3).get_node_shared_ptr(); + if (converter.canCreate(weightsNode)) { + const auto& weights = converter.createLayer(weightsNode); + res->blobs["weights"] = weights->blobs["custom"]; + res->_weights = weights->blobs["custom"]; + } + + const auto biasNode = node->input_value(4).get_node_shared_ptr(); + if (converter.canCreate(biasNode)) { + const auto& bias = converter.createLayer(biasNode); + res->blobs["biases"] = bias->blobs["custom"]; + res->_biases = bias->blobs["custom"]; + } + return res; + }); + addSpecificCreator({"RNNCellIE"}, [](const std::shared_ptr<::ngraph::Node>& node, const std::map& params) -> CNNLayerPtr { LayerParams attrs = {node->get_friendly_name(), "RNNCell", @@ -672,7 +695,6 @@ void convertFunctionToICNNNetwork(const std::shared_ptr>(), std::make_shared>(), std::make_shared>(), - std::make_shared>(), std::make_shared>(), std::make_shared>(), std::make_shared>(), diff --git a/inference-engine/src/legacy_api/src/ie_cnn_layer_builder_ngraph.cpp b/inference-engine/src/legacy_api/src/ie_cnn_layer_builder_ngraph.cpp index 03ac65d..16bbebf 100644 --- a/inference-engine/src/legacy_api/src/ie_cnn_layer_builder_ngraph.cpp +++ b/inference-engine/src/legacy_api/src/ie_cnn_layer_builder_ngraph.cpp @@ -1867,54 +1867,6 @@ CNNLayer::Ptr NodeConverter::createLayer(const std:: } template <> -CNNLayer::Ptr NodeConverter::createLayer(const std::shared_ptr& layer) const { - LayerParams params = {layer->get_friendly_name(), "LSTMCell", - details::convertPrecision(layer->get_output_element_type(0))}; - auto castedLayer = ngraph::as_type_ptr(layer); - if (castedLayer == nullptr) THROW_IE_EXCEPTION << "Cannot get " << params.type << " layer " << params.name; - - auto res = std::make_shared(params); - res->params["hidden_size"] = asString(castedLayer->get_hidden_size()); - std::string value; - for (const auto& val : castedLayer->get_activations()) { - if (!value.empty()) value += ","; - value += val; - } - res->params["activations"] = value; - - value.clear(); - for (const auto& val : castedLayer->get_activations_alpha()) { - if (!value.empty()) value += ","; - value += val; - } - res->params["activations_alpha"] = value; - - value.clear(); - for (const auto& val : castedLayer->get_activations_beta()) { - if (!value.empty()) value += ","; - value += val; - } - res->params["activations_beta"] = value; - res->params["clip"] = asString(castedLayer->get_clip()); - - NodeConverter converter; - const auto weightsNode = layer->input_value(3).get_node_shared_ptr(); - if (converter.canCreate(weightsNode)) { - const auto& weights = converter.createLayer(weightsNode); - res->blobs["weights"] = weights->blobs["custom"]; - res->_weights = weights->blobs["custom"]; - } - - const auto biasNode = layer->input_value(4).get_node_shared_ptr(); - if (converter.canCreate(biasNode)) { - const auto& bias = converter.createLayer(biasNode); - res->blobs["biases"] = bias->blobs["custom"]; - res->_biases = bias->blobs["custom"]; - } - return res; -} - -template <> CNNLayer::Ptr NodeConverter::createLayer(const std::shared_ptr& layer) const { LayerParams params = {layer->get_friendly_name(), "Gemm", details::convertPrecision(layer->get_output_element_type(0))}; diff --git a/inference-engine/src/readers/ir_reader/ie_ir_parser.cpp b/inference-engine/src/readers/ir_reader/ie_ir_parser.cpp index e291ba0..d34891e 100644 --- a/inference-engine/src/readers/ir_reader/ie_ir_parser.cpp +++ b/inference-engine/src/readers/ir_reader/ie_ir_parser.cpp @@ -439,7 +439,7 @@ std::shared_ptr V10Parser::createNode(const std::vector>("Select"), std::make_shared>("LRN"), std::make_shared>("MVN"), - std::make_shared>("LSTMCell"), + std::make_shared>("LSTMCell"), std::make_shared>("MaxPool"), std::make_shared>("Maximum"), std::make_shared>("Minimum"), @@ -910,7 +910,7 @@ std::shared_ptr V10Parser::LayerCreator::crea // LSTMCell layer template <> -std::shared_ptr V10Parser::LayerCreator::createLayer( +std::shared_ptr V10Parser::LayerCreator::createLayer( const ngraph::OutputVector& inputs, const pugi::xml_node& node, std::istream& binStream, const GenericLayerParams& layerParsePrms) { checkParameters(inputs, layerParsePrms, 6); @@ -922,7 +922,7 @@ std::shared_ptr V10Parser::LayerCreator::cre std::vector activations_alpha = getParameters(dn, "activations_alpha", {}); std::vector activations_beta = getParameters(dn, "activations_beta", {}); float clip = GetFloatAttr(dn, "clip", 0.f); - return std::make_shared(inputs[0], inputs[1], inputs[2], inputs[3], inputs[4], inputs[5], + return std::make_shared(inputs[0], inputs[1], inputs[2], inputs[3], inputs[4], inputs[5], GetUInt64Attr(dn, "hidden_size"), ngraph::op::LSTMWeightsFormat::IFCO, activations, activations_alpha, activations_beta, clip); } diff --git a/inference-engine/src/transformations/include/ngraph_ops/lstm_cell_ie.hpp b/inference-engine/src/transformations/include/ngraph_ops/lstm_cell_ie.hpp index 733630b..7b5b9b5 100644 --- a/inference-engine/src/transformations/include/ngraph_ops/lstm_cell_ie.hpp +++ b/inference-engine/src/transformations/include/ngraph_ops/lstm_cell_ie.hpp @@ -41,13 +41,14 @@ public: const std::vector& get_activations_alpha() { return m_activations_alpha; } const std::vector& get_activations_beta() { return m_activations_beta; } float get_clip() {return m_clip;} + bool visit_attributes(AttributeVisitor& visitor) override; protected: int64_t m_hidden_size{}; - const std::vector m_activations; - const std::vector m_activations_alpha; - const std::vector m_activations_beta; + std::vector m_activations; + std::vector m_activations_alpha; + std::vector m_activations_beta; float m_clip; }; diff --git a/inference-engine/src/transformations/include/transformations/gru_cell_decomposition.hpp b/inference-engine/src/transformations/include/transformations/gru_cell_decomposition.hpp new file mode 100644 index 0000000..784df58 --- /dev/null +++ b/inference-engine/src/transformations/include/transformations/gru_cell_decomposition.hpp @@ -0,0 +1,41 @@ +// Copyright (C) 2020 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#pragma once + +#include +#include + +#include + +#include + +namespace ngraph { +namespace pass { + +class TRANSFORMATIONS_API GRUCellDecomposition; + +} // namespace pass +} // namespace ngraph + +/** + * @ingroup ie_transformation_common_api + * @brief GRUCellDecomposition transformation decomposes GRUCell layer with inputs X, H, W, R, B + * to Add, Split, MatMul, Multiply and Subtract ops according to the formula: + (.) - Denotes element-wise multiplication. + * - Denotes dot product. + f, g - are activation functions + + zt = f(Xt*(Wz^T) + Ht-1*(Rz^T) + Wbz + Rbz) + rt = f(Xt*(Wr^T) + Ht-1*(Rr^T) + Wbr + Rbr) + ht = g(Xt*(Wh^T) + (rt (.) Ht-1)*(Rh^T) + Rbh + Wbh) # when linear_before_reset := false # (default) + ht = g(Xt*(Wh^T) + (rt (.) (Ht-1*(Rh^T) + Rbh)) + Wbh) # when linear_before_reset:= true + Ht = (1 - zt) (.) ht + zt (.) Ht-1 + * * + */ + +class ngraph::pass::GRUCellDecomposition: public ngraph::pass::MatcherPass { +public: + GRUCellDecomposition(); +}; diff --git a/inference-engine/src/transformations/include/transformations/lstm_cell_decomposition.hpp b/inference-engine/src/transformations/include/transformations/lstm_cell_decomposition.hpp new file mode 100644 index 0000000..dd381a7 --- /dev/null +++ b/inference-engine/src/transformations/include/transformations/lstm_cell_decomposition.hpp @@ -0,0 +1,42 @@ +// Copyright (C) 2020 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#pragma once + +#include +#include + +#include + +#include + +namespace ngraph { +namespace pass { + +class TRANSFORMATIONS_API LSTMCellDecomposition; + +} // namespace pass +} // namespace ngraph + +/** + * @ingroup ie_transformation_common_api + * @brief LSTMCellDecomposition transformation decomposes LSTMCell layer with inputs X, H, C, W, R, B + * to Add, Split, MatMul, Multiply ops according to the formula: + * (.) - Denotes element-wise multiplication. + * - Denotes dot product. + f, g, h - are activation functions. + + * it = f(Xt*(Wi^T) + Ht-1*(Ri^T) + Wbi + Rbi) + ft = f(Xt*(Wf^T) + Ht-1*(Rf^T) + Wbf + Rbf) + ct = g(Xt*(Wc^T) + Ht-1*(Rc^T) + Wbc + Rbc) + ot = f(Xt*(Wo^T) + Ht-1*(Ro^T) + Wbo + Rbo) + Ct = ft (.) Ct-1 + it (.) ct + Ht = ot (.) h(Ct) + * * + */ + +class ngraph::pass::LSTMCellDecomposition: public ngraph::pass::MatcherPass { +public: + LSTMCellDecomposition(); +}; diff --git a/inference-engine/src/transformations/include/transformations/rnn_cell_decomposition.hpp b/inference-engine/src/transformations/include/transformations/rnn_cell_decomposition.hpp new file mode 100644 index 0000000..bf25e35 --- /dev/null +++ b/inference-engine/src/transformations/include/transformations/rnn_cell_decomposition.hpp @@ -0,0 +1,36 @@ +// Copyright (C) 2020 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#pragma once + +#include +#include + +#include + +#include + +namespace ngraph { +namespace pass { + +class TRANSFORMATIONS_API RNNCellDecomposition; + +} // namespace pass +} // namespace ngraph + +/** + * @ingroup ie_transformation_common_api + * @brief RNNCellDecomposition transformation decomposes RNNCell layer with inputs X, H, W, R, B + * to Add, MatMul ops according to the formula: + * - Denotes dot product. + f - is an activation functions. + + * Ht = f(Xt*(Wi^T) + Ht-1*(Ri^T) + Wbi + Rbi) + * * + */ + +class ngraph::pass::RNNCellDecomposition: public ngraph::pass::MatcherPass { +public: + RNNCellDecomposition(); +}; diff --git a/inference-engine/src/transformations/include/transformations/utils/utils.hpp b/inference-engine/src/transformations/include/transformations/utils/utils.hpp index 2783bab..4bd8586 100644 --- a/inference-engine/src/transformations/include/transformations/utils/utils.hpp +++ b/inference-engine/src/transformations/include/transformations/utils/utils.hpp @@ -101,6 +101,9 @@ TRANSFORMATIONS_API bool has_f16_constants(const std::shared_ptr activation(const std::string& activation_name, + const ngraph::Output& apply_to); + } // namespace util } // namespace op } // namespace ngraph diff --git a/inference-engine/src/transformations/src/ngraph_ops/lstm_cell_ie.cpp b/inference-engine/src/transformations/src/ngraph_ops/lstm_cell_ie.cpp index 196ad4c..58d0fb4 100644 --- a/inference-engine/src/transformations/src/ngraph_ops/lstm_cell_ie.cpp +++ b/inference-engine/src/transformations/src/ngraph_ops/lstm_cell_ie.cpp @@ -37,6 +37,15 @@ void op::LSTMCellIE::validate_and_infer_types() { set_output_type(1, arg_type, output_shape); } +bool ngraph::op::LSTMCellIE::visit_attributes(AttributeVisitor& visitor) { + visitor.on_attribute("hidden_size", m_hidden_size); + visitor.on_attribute("activations", m_activations); + visitor.on_attribute("activations_alpha", m_activations_alpha); + visitor.on_attribute("activations_beta", m_activations_beta); + visitor.on_attribute("clip", m_clip); + return true; +} + shared_ptr op::LSTMCellIE::clone_with_new_inputs(const OutputVector& new_args) const { check_new_args_count(this, new_args); return make_shared(new_args.at(0), new_args.at(1), new_args.at(2), new_args.at(3), new_args.at(4), diff --git a/inference-engine/src/transformations/src/transformations/convert_opset1_to_legacy/convert_cells_to_cells_ie.cpp b/inference-engine/src/transformations/src/transformations/convert_opset1_to_legacy/convert_cells_to_cells_ie.cpp index 91960c9..4bd931d 100644 --- a/inference-engine/src/transformations/src/transformations/convert_opset1_to_legacy/convert_cells_to_cells_ie.cpp +++ b/inference-engine/src/transformations/src/transformations/convert_opset1_to_legacy/convert_cells_to_cells_ie.cpp @@ -9,22 +9,25 @@ #include #include +#include #include #include +#include #include #include #include ngraph::pass::ConvertLSTMCellMatcher::ConvertLSTMCellMatcher() { - auto lstm_cell_ngraph = ngraph::pattern::wrap_type(); - + auto is_supported_lstm_cell = [](const std::shared_ptr& n) { + return pattern::has_class()(n) || pattern::has_class()(n); + }; + auto any_lstm = std::make_shared(element::f32, Shape{}, is_supported_lstm_cell); ngraph::matcher_pass_callback callback = [](pattern::Matcher& m) { - auto lstm_cell = std::dynamic_pointer_cast (m.get_match_root()); + auto lstm_cell = std::dynamic_pointer_cast(m.get_match_root()); if (!lstm_cell) { return false; } - auto W = std::dynamic_pointer_cast (lstm_cell->input_value(3).get_node_shared_ptr()); if (!W) { return false; @@ -53,7 +56,7 @@ ngraph::pass::ConvertLSTMCellMatcher::ConvertLSTMCellMatcher() { return true; }; - auto m = std::make_shared(lstm_cell_ngraph, "ConvertLSTMCellToLSTMCellIE"); + auto m = std::make_shared(any_lstm, "ConvertLSTMCellToLSTMCellIE"); this->register_matcher(m, callback); } diff --git a/inference-engine/src/transformations/src/transformations/gru_cell_decomposition.cpp b/inference-engine/src/transformations/src/transformations/gru_cell_decomposition.cpp new file mode 100644 index 0000000..7489da1 --- /dev/null +++ b/inference-engine/src/transformations/src/transformations/gru_cell_decomposition.cpp @@ -0,0 +1,104 @@ +// Copyright (C) 2020 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "transformations/gru_cell_decomposition.hpp" + +#include +#include + +#include +#include +#include +#include + +ngraph::pass::GRUCellDecomposition::GRUCellDecomposition() { + auto gru_cell = ngraph::pattern::wrap_type(); + ngraph::matcher_pass_callback callback = [](ngraph::pattern::Matcher& m) { + auto gru_cell = std::dynamic_pointer_cast (m.get_match_root()); + if (!gru_cell) { + return false; + } + + const Output& X = gru_cell->input_value(0); + const Output& H_t = gru_cell->input_value(1); + const Output& W = gru_cell->input_value(2); + const Output& R = gru_cell->input_value(3); + const Output& B = gru_cell->input_value(4); + + // Xt*(W^T) + auto Xt_W = std::make_shared(X, W, false, true); + // Ht-1*(R^T) + auto Ht_R = std::make_shared(H_t, R, false, true); + + // split to gates: + auto axis_0 = ngraph::opset4::Constant::create(element::i64, Shape{}, {0}); + auto axis_1 = ngraph::opset4::Constant::create(element::i64, Shape{}, {1}); + auto Xt_W_zrh = std::make_shared(Xt_W, axis_1, 3); + auto R_zrh = std::make_shared(R, axis_0, 3); + auto Ht_R_zrh = std::make_shared(Ht_R, axis_1, 3); + auto biases_zrh = std::make_shared(B, axis_0, gru_cell->get_linear_before_reset() ? 4 : 3); + + // Xt*(Wz^T) + Ht-1*(Rz^T) + Wbz + Rbz + auto add_z_1 = std::make_shared(Ht_R_zrh->output(0), biases_zrh->output(0)); + auto add_z_2 = std::make_shared(Xt_W_zrh->output(0), add_z_1); + + // Xt*(Wr^T) + Ht-1*(Rr^T) + Wbr + Rbr + auto add_r_1 = std::make_shared(Ht_R_zrh->output(1), biases_zrh->output(1)); + auto add_r_2 = std::make_shared(Xt_W_zrh->output(1), add_r_1); + + auto clip = gru_cell->get_clip(); + std::shared_ptr clamp_z = add_z_2; + std::shared_ptr clamp_r = add_r_2; + if (clip > 0.f) { + clamp_z = std::make_shared(add_z_2, -clip, clip); + clamp_r = std::make_shared(add_r_2, -clip, clip); + ngraph::copy_runtime_info(gru_cell, {clamp_z, clamp_r}); + } + + // zt = f(Xt*(Wz^T) + Ht-1*(Rz^T) + Wbz + Rbz) + auto z_t = ngraph::op::util::activation(gru_cell->get_activations()[0], clamp_z); + // rt = f(Xt*(Wr^T) + Ht-1*(Rr^T) + Wbr + Rbr) + auto r_t = ngraph::op::util::activation(gru_cell->get_activations()[0], clamp_r); + + std::shared_ptr _h; + if (gru_cell->get_linear_before_reset()) { + // _h = Xt*(Wh^T) + (rt (.) (Ht-1*(Rh^T) + Rbh)) + Wbh + auto Ht_Rh_Rbh = std::make_shared(Ht_R_zrh->output(2), biases_zrh->output(3)); + auto mul_h_1 = std::make_shared(r_t, Ht_Rh_Rbh); + auto add_h_1 = std::make_shared(mul_h_1, biases_zrh->output(2)); + _h = std::make_shared(Xt_W_zrh->output(2), add_h_1); + ngraph::copy_runtime_info(gru_cell, {Ht_Rh_Rbh, mul_h_1, add_h_1, _h}); + } else { + // _h = Xt*(Wh^T) + (rt (.) Ht-1)*(Rh^T) + Rbh + Wbh + auto rt_Ht = std::make_shared(r_t, H_t); + auto mul_h_1 = std::make_shared(rt_Ht, R_zrh->output(2), false, true); + auto add_h_1 = std::make_shared(mul_h_1, biases_zrh->output(2)); + _h = std::make_shared(Xt_W_zrh->output(2), add_h_1); + ngraph::copy_runtime_info(gru_cell, {rt_Ht, mul_h_1, add_h_1, _h}); + } + // ht = g(_h) + std::shared_ptr clamp_h = _h; + if (clip > 0.f) { + clamp_h = std::make_shared(_h, -clip, clip); + ngraph::copy_runtime_info(gru_cell, clamp_h); + } + auto h_t = ngraph::op::util::activation(gru_cell->get_activations()[1], clamp_h); + + // Ht = (1 - zt) (.) ht + zt (.) Ht-1 + auto one = opset4::Constant::create(z_t->get_element_type(), Shape{1}, {1.f}); + auto sub = std::make_shared(one, z_t); + auto mul_1 = std::make_shared(sub, h_t); + auto mul_2 = std::make_shared(z_t, H_t); + auto out_H = std::make_shared(mul_1, mul_2); + + out_H->set_friendly_name(gru_cell->get_friendly_name()); + ngraph::copy_runtime_info(gru_cell, {Xt_W, Ht_R, axis_0, Xt_W_zrh, R_zrh, Ht_R_zrh, biases_zrh, + add_z_1, add_z_2, add_r_1, add_r_2, h_t, one, sub, mul_1, mul_2, out_H}); + ngraph::replace_node(gru_cell, out_H); + return true; + }; + + auto m = std::make_shared(gru_cell, "GRUCellDecomposition"); + register_matcher(m, callback); +} diff --git a/inference-engine/src/transformations/src/transformations/lstm_cell_decomposition.cpp b/inference-engine/src/transformations/src/transformations/lstm_cell_decomposition.cpp new file mode 100644 index 0000000..3cf6b5b --- /dev/null +++ b/inference-engine/src/transformations/src/transformations/lstm_cell_decomposition.cpp @@ -0,0 +1,85 @@ +// Copyright (C) 2020 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "transformations/lstm_cell_decomposition.hpp" + +#include +#include + +#include +#include +#include +#include + +ngraph::pass::LSTMCellDecomposition::LSTMCellDecomposition() { + auto lstm_cell = ngraph::pattern::wrap_type(); + ngraph::matcher_pass_callback callback = [](ngraph::pattern::Matcher& m) { + auto lstm_cell = std::dynamic_pointer_cast (m.get_match_root()); + if (!lstm_cell) { + return false; + } + const Output& X = lstm_cell->input_value(0); + const Output& H_t = lstm_cell->input_value(1); + const Output& C_t = lstm_cell->input_value(2); + const Output& W = lstm_cell->input_value(3); + const Output& R = lstm_cell->input_value(4); + const Output& bias = lstm_cell->input_value(5); + + // Xt*(W^T) + auto Xt_W = std::make_shared(X, W, false, true); + // Ht-1*(R^T) + auto Ht_R = std::make_shared(H_t, R, false, true); + // Xt*(W^T) + Ht-1*(R^T) + Wb + Rb + auto add = std::make_shared(Ht_R, bias); + auto XHB = std::make_shared(Xt_W, add); + + auto axis_node = ngraph::opset4::Constant::create(element::u64, Shape{}, {1}); + auto split = std::make_shared(XHB, axis_node, 4); + Output f = split->output(0); + Output i = split->output(1); + Output c = split->output(2); + Output o = split->output(3); + + auto clip = lstm_cell->get_clip(); + if (clip > 0.f) { + auto clamp_f = std::make_shared(f, -clip, clip); + auto clamp_i = std::make_shared(i, -clip, clip); + auto clamp_c = std::make_shared(c, -clip, clip); + auto clamp_o = std::make_shared(o, -clip, clip); + f = clamp_f; + i = clamp_i; + c = clamp_c; + o = clamp_o; + ngraph::copy_runtime_info(lstm_cell, {clamp_f, clamp_i, clamp_c, clamp_o}); + } + + // ft = f(Xt*(Wf^T) + Ht-1*(Rf^T) + Wbf + Rbf) + // it = f(Xt*(Wi^T) + Ht-1*(Ri^T) + Wbi + Rbi) + // ct = g(Xt*(Wc^T) + Ht-1*(Rc^T) + Wbc + Rbc) + // ot = f(Xt*(Wo^T) + Ht-1*(Ro^T) + Wbo + Rbo) + auto f_t = ngraph::op::util::activation(lstm_cell->get_activations()[0], f); + auto i_t = ngraph::op::util::activation(lstm_cell->get_activations()[0], i); + auto c_t = ngraph::op::util::activation(lstm_cell->get_activations()[1], c); + auto o_t = ngraph::op::util::activation(lstm_cell->get_activations()[0], o); + + // Ct = ft (.) Ct-1 + it (.) ct + auto mul1 = std::make_shared(f_t, C_t); + auto mul2 = std::make_shared(i_t, c_t); + auto out_C = std::make_shared(mul1, mul2); + + // H = ot (.) h(Ct) + auto hC = ngraph::op::util::activation(lstm_cell->get_activations()[2], out_C); + auto out_H = std::make_shared(o_t, hC); + + out_H->set_friendly_name(lstm_cell->get_friendly_name()+".0"); + out_C->set_friendly_name(lstm_cell->get_friendly_name()+".1"); + ngraph::copy_runtime_info(lstm_cell, {Xt_W, Ht_R, add, split, mul1, mul2, out_H, hC, out_C, axis_node, XHB, + f_t, i_t, c_t, o_t}); + ngraph::replace_node(lstm_cell, {out_H->output(0), out_C->output(0)}); + return true; + }; + + auto m = std::make_shared(lstm_cell, "LSTMCellDecomposition"); + register_matcher(m, callback); +} diff --git a/inference-engine/src/transformations/src/transformations/rnn_cell_decomposition.cpp b/inference-engine/src/transformations/src/transformations/rnn_cell_decomposition.cpp new file mode 100644 index 0000000..d02938f --- /dev/null +++ b/inference-engine/src/transformations/src/transformations/rnn_cell_decomposition.cpp @@ -0,0 +1,52 @@ +// Copyright (C) 2020 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include "transformations/rnn_cell_decomposition.hpp" + +#include +#include + +#include +#include +#include +#include + +ngraph::pass::RNNCellDecomposition::RNNCellDecomposition() { + auto rnn_cell = ngraph::pattern::wrap_type(); + ngraph::matcher_pass_callback callback = [](ngraph::pattern::Matcher& m) { + auto rnn_cell = std::dynamic_pointer_cast (m.get_match_root()); + if (!rnn_cell) { + return false; + } + const Output& X = rnn_cell->input_value(0); + const Output& H_t = rnn_cell->input_value(1); + const Output& W = rnn_cell->input_value(2); + const Output& R = rnn_cell->input_value(3); + const Output& bias = rnn_cell->input_value(4); + + // Xt*(W^T) + auto Xt_W = std::make_shared(X, W, false, true); + // Ht-1*(R^T) + auto Ht_R = std::make_shared(H_t, R, false, true); + // Xt*(W^T) + Ht-1*(R^T) + Wb + Rb + auto add = std::make_shared(Ht_R, bias); + auto i_t = std::make_shared(Xt_W, add); + + // f(Xt*(Wi^T) + Ht-1*(Ri^T) + Wbi + Rbi) + auto clip = rnn_cell->get_clip(); + std::shared_ptr clamp = i_t; + if (clip > 0.f) { + clamp = std::make_shared(i_t, -clip, clip); + ngraph::copy_runtime_info(rnn_cell, clamp); + } + auto out = ngraph::op::util::activation(rnn_cell->get_activations()[0], clamp); + out->set_friendly_name(rnn_cell->get_friendly_name()); + ngraph::copy_runtime_info(rnn_cell, {Xt_W, Ht_R, add, i_t, out}); + ngraph::replace_node(rnn_cell, out); + return true; + }; + + auto m = std::make_shared(rnn_cell, "RNNCellDecomposition"); + register_matcher(m, callback); +} diff --git a/inference-engine/src/transformations/src/transformations/utils/utils.cpp b/inference-engine/src/transformations/src/transformations/utils/utils.cpp index dbd2e21..8f94b57 100644 --- a/inference-engine/src/transformations/src/transformations/utils/utils.cpp +++ b/inference-engine/src/transformations/src/transformations/utils/utils.cpp @@ -108,6 +108,18 @@ bool check_for_broadcast(const ngraph::Shape &ref_shape, const ngraph::Shape &ot return false; } +std::shared_ptr activation(const std::string& activation_name, const ngraph::Output& apply_to) { + if (activation_name == "relu") { + return std::make_shared(apply_to); + } else if (activation_name == "sigmoid") { + return std::make_shared(apply_to); + } else if (activation_name == "tanh") { + return std::make_shared(apply_to); + } else { + throw ngraph_error("Unsupported activation function"); + } +} + } // namespace util } // namespace op } // namespace ngraph diff --git a/inference-engine/tests/functional/inference_engine/ngraph_reader/ti.cpp b/inference-engine/tests/functional/inference_engine/ngraph_reader/ti.cpp index 1c97a0b..f2e4193 100644 --- a/inference-engine/tests/functional/inference_engine/ngraph_reader/ti.cpp +++ b/inference-engine/tests/functional/inference_engine/ngraph_reader/ti.cpp @@ -4,7 +4,7 @@ #include #include "ngraph_reader_tests.hpp" -TEST_F(NGraphReaderTests, ReadTensorIteratorNetwork) { +TEST_F(NGraphReaderTests, ReadTensorIteratorNetwork_opset1) { std::string model_v10 = R"V0G0N( @@ -457,7 +457,7 @@ TEST_F(NGraphReaderTests, ReadTensorIteratorNetwork) { }); } -TEST_F(NGraphReaderTests, ReadTensorIteratorNetwork_resnet) { +TEST_F(NGraphReaderTests, ReadTensorIteratorNetwork_resnet_opset1) { std::string model_v10 = R"V0G0N( @@ -948,7 +948,7 @@ TEST_F(NGraphReaderTests, ReadTensorIteratorNetwork_resnet) { }); } -TEST_F(NGraphReaderTests, ReadTensorIteratorNetwork_negative_stride) { +TEST_F(NGraphReaderTests, ReadTensorIteratorNetwork_negative_stride_opset1) { std::string model_v10 = R"V0G0N( @@ -1400,3 +1400,1400 @@ TEST_F(NGraphReaderTests, ReadTensorIteratorNetwork_negative_stride) { data[393732] = 256; }); } + +TEST_F(NGraphReaderTests, ReadTensorIteratorNetwork_opset4) { + std::string model_v10 = R"V0G0N( + + + + + + + 1 + 25 + 512 + + + + + + + + 1 + 256 + + + + + + + + 1 + 256 + + + + + + + 1 + 25 + 512 + + + 1 + 256 + + + 1 + 256 + + + + + 1 + 25 + 256 + + + + + + + + + + + + + + + + + + + 1 + 1 + 512 + + + + + + + + 2 + + + + + + + + 1 + 1 + 512 + + + 2 + + + + + 1 + 512 + + + + + + + + 1 + 256 + + + + + + + + 1 + 256 + + + + + + + + 1024 + 512 + + + + + + + + 1024 + 256 + + + + + + + + 1024 + + + + + + + + 1 + 512 + + + 1 + 256 + + + 1 + 256 + + + 1024 + 512 + + + 1024 + 256 + + + 1024 + + + + + 1 + 256 + + + 1 + 256 + + + + + + + 1 + 256 + + + + + + + 1 + 256 + + + + + + + + 3 + + + + + + + + 1 + 256 + + + 3 + + + + + 1 + 1 + 256 + + + + + + + 1 + 1 + 256 + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 25 + 256 + + + + + + + + + + + + )V0G0N"; + std::string model_v6 = R"VOGON( + + + + + + 1 + 25 + 512 + + + + + + + 1 + 256 + + + + + + + 1 + 256 + + + + + + + 1 + 25 + 512 + + + 1 + 256 + + + 1 + 256 + + + + + 1 + 25 + 256 + + + + + + + + + + + + + + + + + + 2 + + + + + + + + + + 1 + 1 + 512 + + + 2 + + + + + 1 + 512 + + + + + + + + 1 + 512 + + + 1 + 256 + + + 1 + 256 + + + + + 1 + 256 + + + 1 + 256 + + + + + + + + + + + 3 + + + + + + + + + + 1 + 256 + + + 3 + + + + + 1 + 1 + 256 + + + + + + + + + + + + + + + + + + + + )VOGON"; + + compareIRs(model_v10, model_v6, 3149864, [](Blob::Ptr& weights) { + auto *data = weights->buffer().as(); + data[0] = 1; + data[1] = 512; + + data[393730] = 1; + data[393731] = 1; + data[393732] = 256; + }); +} + +TEST_F(NGraphReaderTests, ReadTensorIteratorNetwork_resnet_opset4) { + std::string model_v10 = R"V0G0N( + + + + + + + 16 + 1 + 512 + + + + + + + + 1 + 512 + + + + + + + + 1 + 512 + + + + + + + 16 + 1 + 512 + + + 1 + 512 + + + 1 + 512 + + + + + 16 + 1 + 512 + + + 1 + 512 + + + 1 + 512 + + + + + + + + + + + + + + + + + + + + + 1 + 1 + 512 + + + + + + + + 2 + + + + + + + + 1 + 1 + 512 + + + 2 + + + + + 1 + 512 + + + + + + + + 1 + 512 + + + + + + + + 1 + 512 + + + + + + + + 2048 + 512 + + + + + + + + 2048 + 512 + + + + + + + + 2048 + + + + + + + + 1 + 512 + + + 1 + 512 + + + 1 + 512 + + + 2048 + 512 + + + 2048 + 512 + + + 2048 + + + + + 1 + 512 + + + 1 + 512 + + + + + + + 1 + 512 + + + + + + + 1 + 512 + + + + + + + + 3 + + + + + + + + 1 + 512 + + + 3 + + + + + 1 + 1 + 512 + + + + + + + 1 + 1 + 512 + + + + + + + + + + + + + + + + + + + + + + + + + 16 + 1 + 512 + + + + + + + 1 + 512 + + + + + + + 1 + 512 + + + + + + + + + + + + + + )V0G0N"; + std::string model_v6 = R"V0G0N( + + + + + + 16 + 1 + 512 + + + + + + + 1 + 512 + + + + + + + 1 + 512 + + + + + + + 16 + 1 + 512 + + + 1 + 512 + + + 1 + 512 + + + + + 16 + 1 + 512 + + + 1 + 512 + + + 1 + 512 + + + + + + + + + + + + + + + + + + + + 2 + + + + + + + + + + 1 + 1 + 512 + + + 2 + + + + + 1 + 512 + + + + + + + + 1 + 512 + + + 1 + 512 + + + 1 + 512 + + + + + 1 + 512 + + + 1 + 512 + + + + + + + + + + + 3 + + + + + + + + + + 1 + 512 + + + 3 + + + + + 1 + 1 + 512 + + + + + + + + + + + + + + + + + + + + )V0G0N"; + + compareIRs(model_v10, model_v6, 8396840, [](Blob::Ptr& weights) { + auto *data = weights->buffer().as(); + data[0] = 1; + data[1] = 512; + + data[1049602] = 1; + data[1049603] = 1; + data[1049604] = 512; + }); +} + +TEST_F(NGraphReaderTests, ReadTensorIteratorNetwork_negative_stride_opset4) { + std::string model_v10 = R"V0G0N( + + + + + + + 1 + 25 + 512 + + + + + + + + 1 + 256 + + + + + + + + 1 + 256 + + + + + + + 1 + 25 + 512 + + + 1 + 256 + + + 1 + 256 + + + + + 1 + 25 + 256 + + + + + + + + + + + + + + + + + + + 1 + 1 + 512 + + + + + + + + 2 + + + + + + + + 1 + 1 + 512 + + + 2 + + + + + 1 + 512 + + + + + + + + 1 + 256 + + + + + + + + 1 + 256 + + + + + + + + 1024 + 512 + + + + + + + + 1024 + 256 + + + + + + + + 1024 + + + + + + + + 1 + 512 + + + 1 + 256 + + + 1 + 256 + + + 1024 + 512 + + + 1024 + 256 + + + 1024 + + + + + 1 + 256 + + + 1 + 256 + + + + + + + 1 + 256 + + + + + + + 1 + 256 + + + + + + + + 3 + + + + + + + + 1 + 256 + + + 3 + + + + + 1 + 1 + 256 + + + + + + + 1 + 1 + 256 + + + + + + + + + + + + + + + + + + + + + + + + + 1 + 25 + 256 + + + + + + + + + + + + )V0G0N"; + std::string model_v6 = R"VOGON( + + + + + + 1 + 25 + 512 + + + + + + + 1 + 256 + + + + + + + 1 + 256 + + + + + + + 1 + 25 + 512 + + + 1 + 256 + + + 1 + 256 + + + + + 1 + 25 + 256 + + + + + + + + + + + + + + + + + + 2 + + + + + + + + + + 1 + 1 + 512 + + + 2 + + + + + 1 + 512 + + + + + + + + 1 + 512 + + + 1 + 256 + + + 1 + 256 + + + + + 1 + 256 + + + 1 + 256 + + + + + + + + + + + 3 + + + + + + + + + + 1 + 256 + + + 3 + + + + + 1 + 1 + 256 + + + + + + + + + + + + + + + + + + + + )VOGON"; + + compareIRs(model_v10, model_v6, 3149864, [](Blob::Ptr& weights) { + auto *data = weights->buffer().as(); + data[0] = 1; + data[1] = 512; + + data[393730] = 1; + data[393731] = 1; + data[393732] = 256; + }); +} diff --git a/inference-engine/tests/functional/inference_engine/transformations/convert_cells_to_cells_ie_test.cpp b/inference-engine/tests/functional/inference_engine/transformations/convert_cells_to_cells_ie_test.cpp index 516cf85..3f6bff5 100644 --- a/inference-engine/tests/functional/inference_engine/transformations/convert_cells_to_cells_ie_test.cpp +++ b/inference-engine/tests/functional/inference_engine/transformations/convert_cells_to_cells_ie_test.cpp @@ -14,6 +14,7 @@ #include #include #include +#include #include #include #include @@ -129,7 +130,7 @@ TEST(TransformationTests, RNNCellConversionTest) { ASSERT_TRUE(cell_node->get_friendly_name() == "test_cell") << "Transformation ConvertRNNCellToRNNCellIE should keep output names.\n"; } -TEST(TransformationTests, LSTMCellConversionTest) { +TEST(TransformationTests, LSTMCellConversionTest_opset3) { const size_t batch_size = 2; const size_t input_size = 3; const size_t hidden_size = 3; @@ -186,4 +187,76 @@ TEST(TransformationTests, LSTMCellConversionTest) { auto result_node_of_converted_f = f->get_output_op(0); auto cell_node = result_node_of_converted_f->input(0).get_source_output().get_node_shared_ptr(); ASSERT_TRUE(cell_node->get_friendly_name() == "test_cell") << "Transformation ConvertLSTMCellToLSTMCellIE should keep output names.\n"; -} \ No newline at end of file +} + +TEST(TransformationTests, LSTMCellConversionTest_opset4) { + const size_t batch_size = 2; + const size_t input_size = 3; + const size_t hidden_size = 3; + const size_t gates_count = 4; + + std::shared_ptr f(nullptr), f_ref(nullptr); + std::shared_ptr cell; + { + const auto X = std::make_shared(ngraph::element::f32, + ngraph::Shape{batch_size, input_size}); + const auto W = + std::make_shared(ngraph::element::f32, + ngraph::Shape{gates_count * hidden_size, input_size}); + const auto R = + std::make_shared(ngraph::element::f32, + ngraph::Shape{gates_count * hidden_size, hidden_size}); + const auto H_t = std::make_shared(ngraph::element::f32, + ngraph::Shape{batch_size, hidden_size}); + const auto C_t = std::make_shared(ngraph::element::f32, + ngraph::Shape{batch_size, hidden_size}); + const auto B = std::make_shared(ngraph::element::f32, + ngraph::Shape{gates_count * hidden_size}); + + cell = std::make_shared(X, H_t, C_t, W, R, B, hidden_size); + cell->set_friendly_name("test_cell"); + + f = std::make_shared(ngraph::NodeVector{cell}, ngraph::ParameterVector{X, H_t, C_t}); + ngraph::pass::Manager manager; + manager.register_pass(); + manager.register_pass(); + manager.run_passes(f); + ASSERT_NO_THROW(check_rt_info(f)); + } + + { + const auto X = std::make_shared(ngraph::element::f32, + ngraph::Shape{batch_size, input_size}); + const auto W = + std::make_shared(ngraph::element::f32, + ngraph::Shape{gates_count * hidden_size, input_size}); + const auto R = + std::make_shared(ngraph::element::f32, + ngraph::Shape{gates_count * hidden_size, hidden_size}); + const auto H_t = std::make_shared(ngraph::element::f32, + ngraph::Shape{batch_size, hidden_size}); + const auto C_t = std::make_shared(ngraph::element::f32, + ngraph::Shape{batch_size, hidden_size}); + const auto B = std::make_shared(ngraph::element::f32, + ngraph::Shape{gates_count * hidden_size}); + + auto concat = std::make_shared(ngraph::NodeVector({W, R}), 1); + auto cell_ie = std::make_shared(X, H_t, C_t, concat, B, + cell->get_hidden_size(), + cell->get_activations(), + cell->get_activations_alpha(), + cell->get_activations_beta(), + cell->get_clip()); + cell_ie->set_friendly_name("test_cell"); + + f_ref = std::make_shared(ngraph::NodeVector{cell_ie}, ngraph::ParameterVector{X, H_t, C_t}); + } + + auto res = compare_functions(f, f_ref); + ASSERT_TRUE(res.first) << res.second; + + auto result_node_of_converted_f = f->get_output_op(0); + auto cell_node = result_node_of_converted_f->input(0).get_source_output().get_node_shared_ptr(); + ASSERT_TRUE(cell_node->get_friendly_name() == "test_cell") + << "Transformation ConvertLSTMCellToLSTMCellIE should keep output names.\n"; +} diff --git a/inference-engine/tests/functional/plugin/cpu/shared_tests_instances/single_layer_tests/gru_cell.cpp b/inference-engine/tests/functional/plugin/cpu/shared_tests_instances/single_layer_tests/gru_cell.cpp new file mode 100644 index 0000000..4d015df --- /dev/null +++ b/inference-engine/tests/functional/plugin/cpu/shared_tests_instances/single_layer_tests/gru_cell.cpp @@ -0,0 +1,37 @@ +// Copyright (C) 2019 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include + +#include "single_layer_tests/gru_cell.hpp" +#include "common_test_utils/test_constants.hpp" + +using namespace LayerTestsDefinitions; + +namespace { + std::vector should_decompose{false, true}; + std::vector batch{5}; + std::vector hidden_size{1, 10}; + std::vector input_size{1, 30}; + std::vector> activations = {{"relu", "tanh"}, {"tanh", "sigmoid"}, {"sigmoid", "tanh"}, + {"tanh", "relu"}}; + std::vector clip = {0.0f, 0.7f}; + std::vector linear_before_reset = {true, false}; + std::vector netPrecisions = {InferenceEngine::Precision::FP32, + InferenceEngine::Precision::FP16}; + + INSTANTIATE_TEST_CASE_P(GRUCellCommon, GRUCellTest, + ::testing::Combine( + ::testing::ValuesIn(should_decompose), + ::testing::ValuesIn(batch), + ::testing::ValuesIn(hidden_size), + ::testing::ValuesIn(input_size), + ::testing::ValuesIn(activations), + ::testing::ValuesIn(clip), + ::testing::ValuesIn(linear_before_reset), + ::testing::ValuesIn(netPrecisions), + ::testing::Values(CommonTestUtils::DEVICE_CPU)), + GRUCellTest::getTestCaseName); + +} // namespace diff --git a/inference-engine/tests/functional/plugin/cpu/shared_tests_instances/single_layer_tests/lstm_cell.cpp b/inference-engine/tests/functional/plugin/cpu/shared_tests_instances/single_layer_tests/lstm_cell.cpp new file mode 100644 index 0000000..abf5114 --- /dev/null +++ b/inference-engine/tests/functional/plugin/cpu/shared_tests_instances/single_layer_tests/lstm_cell.cpp @@ -0,0 +1,36 @@ +// Copyright (C) 2019 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include + +#include "single_layer_tests/lstm_cell.hpp" +#include "common_test_utils/test_constants.hpp" + +using namespace LayerTestsDefinitions; + +namespace { + std::vector should_decompose{false, true}; + std::vector batch{5}; + std::vector hidden_size{1, 10}; + std::vector input_size{1, 30}; + std::vector> activations = {{"relu", "sigmoid", "tanh"}, {"sigmoid", "tanh", "tanh"}, + {"tanh", "relu", "sigmoid"}, {"sigmoid", "sigmoid", "sigmoid"}, + {"tanh", "tanh", "tanh"}, {"relu", "relu", "relu"}}; + std::vector clip{0.f, 0.7f}; + std::vector netPrecisions = {InferenceEngine::Precision::FP32, + InferenceEngine::Precision::FP16}; + + INSTANTIATE_TEST_CASE_P(LSTMCellCommon, LSTMCellTest, + ::testing::Combine( + ::testing::ValuesIn(should_decompose), + ::testing::ValuesIn(batch), + ::testing::ValuesIn(hidden_size), + ::testing::ValuesIn(input_size), + ::testing::ValuesIn(activations), + ::testing::ValuesIn(clip), + ::testing::ValuesIn(netPrecisions), + ::testing::Values(CommonTestUtils::DEVICE_CPU)), + LSTMCellTest::getTestCaseName); + +} // namespace diff --git a/inference-engine/tests/functional/plugin/cpu/shared_tests_instances/single_layer_tests/rnn_cell.cpp b/inference-engine/tests/functional/plugin/cpu/shared_tests_instances/single_layer_tests/rnn_cell.cpp new file mode 100644 index 0000000..cf9f572 --- /dev/null +++ b/inference-engine/tests/functional/plugin/cpu/shared_tests_instances/single_layer_tests/rnn_cell.cpp @@ -0,0 +1,34 @@ +// Copyright (C) 2019 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include + +#include "single_layer_tests/rnn_cell.hpp" +#include "common_test_utils/test_constants.hpp" + +using namespace LayerTestsDefinitions; + +namespace { + std::vector should_decompose{false, true}; + std::vector batch{1, 5}; + std::vector hidden_size{1, 10}; + std::vector input_size{1, 30}; + std::vector> activations = {{"relu"}, {"sigmoid"}, {"tanh"}}; + std::vector clip = {0.f, 0.7f}; + std::vector netPrecisions = {InferenceEngine::Precision::FP32, + InferenceEngine::Precision::FP16}; + + INSTANTIATE_TEST_CASE_P(RNNCellCommon, RNNCellTest, + ::testing::Combine( + ::testing::ValuesIn(should_decompose), + ::testing::ValuesIn(batch), + ::testing::ValuesIn(hidden_size), + ::testing::ValuesIn(input_size), + ::testing::ValuesIn(activations), + ::testing::ValuesIn(clip), + ::testing::ValuesIn(netPrecisions), + ::testing::Values(CommonTestUtils::DEVICE_CPU)), + RNNCellTest::getTestCaseName); + +} // namespace diff --git a/inference-engine/tests/functional/plugin/shared/include/single_layer_tests/gru_cell.hpp b/inference-engine/tests/functional/plugin/shared/include/single_layer_tests/gru_cell.hpp new file mode 100644 index 0000000..72f7a4f --- /dev/null +++ b/inference-engine/tests/functional/plugin/shared/include/single_layer_tests/gru_cell.hpp @@ -0,0 +1,38 @@ +// Copyright (C) 2019 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#pragma once + +#include +#include +#include +#include + +#include "functional_test_utils/layer_test_utils.hpp" +#include "ngraph_functions/builders.hpp" +#include "ngraph_functions/utils/ngraph_helpers.hpp" + +namespace LayerTestsDefinitions { + +using GRUCellParams = typename std::tuple< + bool, // using decompose to sub-ops transformation + size_t, // batch + size_t, // hidden size + size_t, // input size + std::vector, // activations + float, // clip + bool, // linear_before_reset + InferenceEngine::Precision, // Network precision + std::string>; // Device name + +class GRUCellTest : public testing::WithParamInterface, + virtual public LayerTestsUtils::LayerTestsCommon { +public: + static std::string getTestCaseName(const testing::TestParamInfo &obj); + +protected: + void SetUp() override; +}; + +} // namespace LayerTestsDefinitions diff --git a/inference-engine/tests/functional/plugin/shared/include/single_layer_tests/lstm_cell.hpp b/inference-engine/tests/functional/plugin/shared/include/single_layer_tests/lstm_cell.hpp new file mode 100644 index 0000000..c43a8a9 --- /dev/null +++ b/inference-engine/tests/functional/plugin/shared/include/single_layer_tests/lstm_cell.hpp @@ -0,0 +1,37 @@ +// Copyright (C) 2019 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#pragma once + +#include +#include +#include +#include + +#include "functional_test_utils/layer_test_utils.hpp" +#include "ngraph_functions/builders.hpp" +#include "ngraph_functions/utils/ngraph_helpers.hpp" + +namespace LayerTestsDefinitions { + +using LSTMCellParams = typename std::tuple< + bool, // using decompose to sub-ops transformation + size_t, // batch + size_t, // hidden size + size_t, // input size + std::vector, // activations + float, // clip + InferenceEngine::Precision, // Network precision + std::string>; // Device name + +class LSTMCellTest : public testing::WithParamInterface, + virtual public LayerTestsUtils::LayerTestsCommon { +public: + static std::string getTestCaseName(const testing::TestParamInfo &obj); + +protected: + void SetUp() override; +}; + +} // namespace LayerTestsDefinitions diff --git a/inference-engine/tests/functional/plugin/shared/include/single_layer_tests/rnn_cell.hpp b/inference-engine/tests/functional/plugin/shared/include/single_layer_tests/rnn_cell.hpp new file mode 100644 index 0000000..8e6a961 --- /dev/null +++ b/inference-engine/tests/functional/plugin/shared/include/single_layer_tests/rnn_cell.hpp @@ -0,0 +1,37 @@ +// Copyright (C) 2019 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#pragma once + +#include +#include +#include +#include + +#include "functional_test_utils/layer_test_utils.hpp" +#include "ngraph_functions/builders.hpp" +#include "ngraph_functions/utils/ngraph_helpers.hpp" + +namespace LayerTestsDefinitions { + +using RNNCellParams = typename std::tuple< + bool, // using decompose to sub-ops transformation + size_t, // batch + size_t, // hidden size + size_t, // input size + std::vector, // activations + float, // clip + InferenceEngine::Precision, // Network precision + std::string>; // Device name + +class RNNCellTest : public testing::WithParamInterface, + virtual public LayerTestsUtils::LayerTestsCommon { +public: + static std::string getTestCaseName(const testing::TestParamInfo &obj); + +protected: + void SetUp() override; +}; + +} // namespace LayerTestsDefinitions diff --git a/inference-engine/tests/functional/plugin/shared/src/single_layer_tests/gru_cell.cpp b/inference-engine/tests/functional/plugin/shared/src/single_layer_tests/gru_cell.cpp new file mode 100644 index 0000000..0750819 --- /dev/null +++ b/inference-engine/tests/functional/plugin/shared/src/single_layer_tests/gru_cell.cpp @@ -0,0 +1,90 @@ +// Copyright (C) 2019 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include +#include +#include +#include +#include + +#include "ie_core.hpp" + +#include "common_test_utils/common_utils.hpp" +#include "functional_test_utils/blob_utils.hpp" +#include "functional_test_utils/precision_utils.hpp" +#include "functional_test_utils/plugin_cache.hpp" +#include "functional_test_utils/skip_tests_config.hpp" + +#include +#include "single_layer_tests/gru_cell.hpp" + +namespace LayerTestsDefinitions { + +std::string GRUCellTest::getTestCaseName(const testing::TestParamInfo &obj) { + bool should_decompose; + size_t batch; + size_t hidden_size; + size_t input_size; + std::vector activations; + std::vector activations_alpha; + std::vector activations_beta; + float clip; + bool linear_before_reset; + std::vector> inputShapes; + InferenceEngine::Precision netPrecision; + std::string targetDevice; + std::tie(should_decompose, batch, hidden_size, input_size, activations, clip, + linear_before_reset, netPrecision, targetDevice) = obj.param; + std::ostringstream result; + result << "decomposition" << should_decompose << "_"; + result << "batch=" << batch << "_"; + result << "hidden_size=" << hidden_size << "_"; + result << "input_size=" << input_size << "_"; + result << "IS=" << CommonTestUtils::vec2str(inputShapes) << "_"; + result << "activations=" << CommonTestUtils::vec2str(activations) << "_"; + result << "clip=" << clip << "_"; + result << "linear_before_reset=" << linear_before_reset << "_"; + result << "netPRC=" << netPrecision.name() << "_"; + result << "targetDevice=" << targetDevice << "_"; + return result.str(); +} + +void GRUCellTest::SetUp() { + bool should_decompose; + size_t batch; + size_t hidden_size; + size_t input_size; + std::vector activations; + std::vector activations_alpha; + std::vector activations_beta; + float clip; + bool linear_before_reset; + InferenceEngine::Precision netPrecision; + std::tie(should_decompose, batch, hidden_size, input_size, activations, clip, linear_before_reset, + netPrecision, targetDevice) = this->GetParam(); + + std::vector> inputShapes = { + {{batch, input_size}, {batch, hidden_size}, {3 * hidden_size, input_size}, + {3 * hidden_size, hidden_size}, {(linear_before_reset? 4 : 3) * hidden_size}}, + }; + + auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision); + auto params = ngraph::builder::makeParams(ngPrc, {inputShapes[0], inputShapes[1]}); + std::vector WRB = {inputShapes[2], inputShapes[3], inputShapes[4]}; + auto gru_cell = ngraph::builder::makeGRUCell(ngraph::helpers::convert2OutputVector(ngraph::helpers::castOps2Nodes(params)), + WRB, hidden_size, activations, {}, {}, clip, linear_before_reset); + ngraph::ResultVector results{std::make_shared(gru_cell->output(0))}; + function = std::make_shared(results, params, "gru_cell"); + if (should_decompose) { + ngraph::pass::Manager m; + m.register_pass(); + m.run_passes(function); + } +} + + +TEST_P(GRUCellTest, CompareWithRefs) { + Run(); +}; +} // namespace LayerTestsDefinitions diff --git a/inference-engine/tests/functional/plugin/shared/src/single_layer_tests/lstm_cell.cpp b/inference-engine/tests/functional/plugin/shared/src/single_layer_tests/lstm_cell.cpp new file mode 100644 index 0000000..2c8c9c7 --- /dev/null +++ b/inference-engine/tests/functional/plugin/shared/src/single_layer_tests/lstm_cell.cpp @@ -0,0 +1,89 @@ +// Copyright (C) 2019 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include +#include +#include +#include +#include + +#include "ie_core.hpp" + +#include "common_test_utils/common_utils.hpp" +#include "functional_test_utils/blob_utils.hpp" +#include "functional_test_utils/precision_utils.hpp" +#include "functional_test_utils/plugin_cache.hpp" +#include "functional_test_utils/skip_tests_config.hpp" + +#include +#include "single_layer_tests/lstm_cell.hpp" + +namespace LayerTestsDefinitions { + +std::string LSTMCellTest::getTestCaseName(const testing::TestParamInfo &obj) { + bool should_decompose; + size_t batch; + size_t hidden_size; + size_t input_size; + std::vector activations; + std::vector activations_alpha; + std::vector activations_beta; + float clip; + InferenceEngine::Precision netPrecision; + std::string targetDevice; + std::tie(should_decompose, batch, hidden_size, input_size, activations, clip, netPrecision, + targetDevice) = obj.param; + std::vector> inputShapes = { + {{batch, input_size}, {batch, hidden_size}, {batch, hidden_size}, {4 * hidden_size, input_size}, + {4 * hidden_size, hidden_size}, {4 * hidden_size}}, + }; + std::ostringstream result; + result << "decomposition" << should_decompose << "_"; + result << "batch=" << batch << "_"; + result << "hidden_size=" << hidden_size << "_"; + result << "input_size=" << input_size << "_"; + result << "IS=" << CommonTestUtils::vec2str(inputShapes) << "_"; + result << "activations=" << CommonTestUtils::vec2str(activations) << "_"; + result << "clip=" << clip << "_"; + result << "netPRC=" << netPrecision.name() << "_"; + result << "targetDevice=" << targetDevice << "_"; + return result.str(); +} + +void LSTMCellTest::SetUp() { + bool should_decompose; + size_t batch; + size_t hidden_size; + size_t input_size; + std::vector activations; + std::vector activations_alpha; + std::vector activations_beta; + float clip; + InferenceEngine::Precision netPrecision; + std::tie(should_decompose, batch, hidden_size, input_size, activations, clip, netPrecision, + targetDevice) = this->GetParam(); + std::vector> inputShapes = { + {{batch, input_size}, {batch, hidden_size}, {batch, hidden_size}, {4 * hidden_size, input_size}, + {4 * hidden_size, hidden_size}, {4 * hidden_size}}, + }; + auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision); + auto params = ngraph::builder::makeParams(ngPrc, {inputShapes[0], inputShapes[1], inputShapes[2]}); + std::vector WRB = {inputShapes[3], inputShapes[4], inputShapes[5]}; + auto lstm_cell = ngraph::builder::makeLSTMCell(ngraph::helpers::convert2OutputVector(ngraph::helpers::castOps2Nodes(params)), + WRB, hidden_size, activations, {}, {}, clip); + ngraph::ResultVector results{std::make_shared(lstm_cell->output(0)), + std::make_shared(lstm_cell->output(1))}; + function = std::make_shared(results, params, "lstm_cell"); + if (should_decompose) { + ngraph::pass::Manager m; + m.register_pass(); + m.run_passes(function); + } +} + + +TEST_P(LSTMCellTest, CompareWithRefs) { + Run(); +}; +} // namespace LayerTestsDefinitions diff --git a/inference-engine/tests/functional/plugin/shared/src/single_layer_tests/rnn_cell.cpp b/inference-engine/tests/functional/plugin/shared/src/single_layer_tests/rnn_cell.cpp new file mode 100644 index 0000000..97c1c08 --- /dev/null +++ b/inference-engine/tests/functional/plugin/shared/src/single_layer_tests/rnn_cell.cpp @@ -0,0 +1,82 @@ +// Copyright (C) 2019 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include +#include +#include +#include +#include + +#include "ie_core.hpp" + +#include "common_test_utils/common_utils.hpp" +#include "functional_test_utils/blob_utils.hpp" +#include "functional_test_utils/precision_utils.hpp" +#include "functional_test_utils/plugin_cache.hpp" +#include "functional_test_utils/skip_tests_config.hpp" + +#include +#include "single_layer_tests/rnn_cell.hpp" + +namespace LayerTestsDefinitions { + +std::string RNNCellTest::getTestCaseName(const testing::TestParamInfo &obj) { + bool should_decompose; + size_t batch; + size_t hidden_size; + size_t input_size; + std::vector activations; + float clip; + InferenceEngine::Precision netPrecision; + std::string targetDevice; + std::tie(should_decompose, batch, hidden_size, input_size, activations, clip, + netPrecision, targetDevice) = obj.param; + std::vector> inputShapes = {{batch, input_size}, {batch, hidden_size}, + {hidden_size, input_size}, {hidden_size, hidden_size}, {hidden_size}}; + std::ostringstream result; + result << "decomposition" << should_decompose << "_"; + result << "batch=" << batch << "_"; + result << "hidden_size=" << hidden_size << "_"; + result << "input_size=" << input_size << "_"; + result << "IS=" << CommonTestUtils::vec2str(inputShapes) << "_"; + result << "activations=" << CommonTestUtils::vec2str(activations) << "_"; + result << "clip=" << clip << "_"; + result << "netPRC=" << netPrecision.name() << "_"; + result << "targetDevice=" << targetDevice << "_"; + return result.str(); +} + +void RNNCellTest::SetUp() { + bool should_decompose; + size_t batch; + size_t hidden_size; + size_t input_size; + std::vector activations; + std::vector activations_alpha; + std::vector activations_beta; + float clip; + InferenceEngine::Precision netPrecision; + std::tie(should_decompose, batch, hidden_size, input_size, activations, clip, + netPrecision, targetDevice) = this->GetParam(); + std::vector> inputShapes = {{batch, input_size}, {batch, hidden_size}, + {hidden_size, input_size}, {hidden_size, hidden_size}, {hidden_size}}; + auto ngPrc = FuncTestUtils::PrecisionUtils::convertIE2nGraphPrc(netPrecision); + auto params = ngraph::builder::makeParams(ngPrc, {inputShapes[0], inputShapes[1]}); + std::vector WRB = {inputShapes[2], inputShapes[3], inputShapes[4]}; + auto rnn_cell = ngraph::builder::makeRNNCell(ngraph::helpers::convert2OutputVector(ngraph::helpers::castOps2Nodes(params)), + WRB, hidden_size, activations, {}, {}, clip); + ngraph::ResultVector results{std::make_shared(rnn_cell)}; + function = std::make_shared(results, params, "rnn_cell"); + if (should_decompose) { + ngraph::pass::Manager m; + m.register_pass(); + m.run_passes(function); + } +} + + +TEST_P(RNNCellTest, CompareWithRefs) { + Run(); +}; +} // namespace LayerTestsDefinitions diff --git a/inference-engine/tests/functional/plugin/shared/src/subgraph_tests/basic_lstm.cpp b/inference-engine/tests/functional/plugin/shared/src/subgraph_tests/basic_lstm.cpp index f98f86b..f2e03f7 100644 --- a/inference-engine/tests/functional/plugin/shared/src/subgraph_tests/basic_lstm.cpp +++ b/inference-engine/tests/functional/plugin/shared/src/subgraph_tests/basic_lstm.cpp @@ -72,7 +72,7 @@ void Basic_LSTM_S::SetUp() { //lstm [1, 10], [1, 118], [1, 118] -> [1, 118], [1, 118] outFormShapes1 = { batch_size, reshape1_shape[2] }; auto constantX = std::make_shared(ngraph::element::i64, ngraph::Shape{2}, outFormShapes1); - auto lstm1 = std::make_shared(std::make_shared(X, constantX, false), + auto lstm1 = std::make_shared(std::make_shared(X, constantX, false), H_t, C_t, weightsNode, reccurrenceWeightsNode, hidden_size); @@ -137,7 +137,7 @@ std::shared_ptr Basic_LSTM_S::CreateGraphWithUnrolledTI() { ngraph::Output H[iterations + 1]; ngraph::Output C[iterations + 1]; - std::shared_ptr lstm[iterations]; + std::shared_ptr lstm[iterations]; H[0] = ngraph::builder::makeConstant(ngPrc, { batch_size, hidden_size }, {}, true); C[0] = ngraph::builder::makeConstant(ngPrc, { batch_size, hidden_size }, {}, true); auto reshape1_shape = reshape1->output(0).get_shape(); @@ -149,7 +149,7 @@ std::shared_ptr Basic_LSTM_S::CreateGraphWithUnrolledTI() { for (size_t i = 0; i < iterations; ++i) { auto X = split1->output(i); - lstm[i] = std::make_shared(std::make_shared(X, constantX, false), + lstm[i] = std::make_shared(std::make_shared(X, constantX, false), H[i], C[i], weightsNode, reccurrenceWeightsNode, hidden_size); diff --git a/inference-engine/tests/ngraph_functions/include/ngraph_functions/builders.hpp b/inference-engine/tests/ngraph_functions/include/ngraph_functions/builders.hpp index 0d1c088..4285467 100644 --- a/inference-engine/tests/ngraph_functions/include/ngraph_functions/builders.hpp +++ b/inference-engine/tests/ngraph_functions/include/ngraph_functions/builders.hpp @@ -389,5 +389,31 @@ std::shared_ptr makePad(const ngraph::Output& data, std::shared_ptr makeBatchNormInference(const ngraph::Output& data, double epsilon); +std::shared_ptr makeLSTMCell(const OutputVector& in, + const std::vector& WRB, + std::size_t hidden_size, + const std::vector& activations = + std::vector{"sigmoid", "tanh", "tanh"}, + const std::vector& activations_alpha = {}, + const std::vector& activations_beta = {}, + float clip = 0.f); + +std::shared_ptr makeGRUCell(const OutputVector& in, + const std::vector& WRB, + std::size_t hidden_size, + const std::vector& activations = + std::vector{"sigmoid", "tanh"}, + const std::vector& activations_alpha = {}, + const std::vector& activations_beta = {}, + float clip = 0.f, + bool linear_before_reset = false); + +std::shared_ptr makeRNNCell(const OutputVector& in, + const std::vector& WRB, + std::size_t hidden_size, + const std::vector& activations = std::vector{"tanh"}, + const std::vector& activations_alpha = {}, + const std::vector& activations_beta = {}, + float clip = 0.f); } // namespace builder } // namespace ngraph diff --git a/inference-engine/tests/ngraph_functions/include/ngraph_functions/subgraph_builders.hpp b/inference-engine/tests/ngraph_functions/include/ngraph_functions/subgraph_builders.hpp index 57b90b3..d6f002f 100644 --- a/inference-engine/tests/ngraph_functions/include/ngraph_functions/subgraph_builders.hpp +++ b/inference-engine/tests/ngraph_functions/include/ngraph_functions/subgraph_builders.hpp @@ -130,7 +130,7 @@ static std::shared_ptr makeTIwithLSTMcell(InferenceEngine::Pre inShape = {N, I}; auto constantX = std::make_shared(ngraph::element::i64, ngraph::Shape{2}, inShape); auto LSTM_cell = - std::make_shared(std::make_shared(X, constantX, false), + std::make_shared(std::make_shared(X, constantX, false), std::make_shared(H_t, constantH, false), std::make_shared(C_t, constantH, false), W_body, diff --git a/inference-engine/tests/ngraph_functions/src/gru_cell.cpp b/inference-engine/tests/ngraph_functions/src/gru_cell.cpp new file mode 100644 index 0000000..487959f --- /dev/null +++ b/inference-engine/tests/ngraph_functions/src/gru_cell.cpp @@ -0,0 +1,30 @@ +// Copyright (C) 2020 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include +#include + +#include "ngraph_functions/builders.hpp" + +namespace ngraph { +namespace builder { + +std::shared_ptr makeGRUCell(const OutputVector& in, + const std::vector& WRB, + std::size_t hidden_size, + const std::vector& activations, + const std::vector& activations_alpha, + const std::vector& activations_beta, + float clip, + bool linear_before_reset) { + std::vector empty; + auto W = ngraph::builder::makeConstant(in[0].get_element_type(), WRB[0], empty, true); + auto R = ngraph::builder::makeConstant(in[0].get_element_type(), WRB[1], empty, true); + auto B = ngraph::builder::makeConstant(in[0].get_element_type(), WRB[2], empty, true); + return std::make_shared(in[0], in[1], W, R, B, hidden_size, activations, + activations_alpha, activations_beta, clip, linear_before_reset); +} + +} // namespace builder +} // namespace ngraph \ No newline at end of file diff --git a/inference-engine/tests/ngraph_functions/src/lstm_cell.cpp b/inference-engine/tests/ngraph_functions/src/lstm_cell.cpp new file mode 100644 index 0000000..38f39f7 --- /dev/null +++ b/inference-engine/tests/ngraph_functions/src/lstm_cell.cpp @@ -0,0 +1,29 @@ +// Copyright (C) 2020 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include +#include + +#include "ngraph_functions/builders.hpp" + +namespace ngraph { +namespace builder { + +std::shared_ptr makeLSTMCell(const std::vector>& in, + const std::vector& WRB, + std::size_t hidden_size, + const std::vector& activations, + const std::vector& activations_alpha, + const std::vector& activations_beta, + float clip) { + std::vector empty; + auto W = ngraph::builder::makeConstant(in[0].get_element_type(), WRB[0], empty, true); + auto R = ngraph::builder::makeConstant(in[0].get_element_type(), WRB[1], empty, true); + auto B = ngraph::builder::makeConstant(in[0].get_element_type(), WRB[2], empty, true); + return std::make_shared(in[0], in[1], in[2], W, R, B, hidden_size, activations, + activations_alpha, activations_beta, clip); +} + +} // namespace builder +} // namespace ngraph \ No newline at end of file diff --git a/inference-engine/tests/ngraph_functions/src/rnn_cell.cpp b/inference-engine/tests/ngraph_functions/src/rnn_cell.cpp new file mode 100644 index 0000000..824c4a8 --- /dev/null +++ b/inference-engine/tests/ngraph_functions/src/rnn_cell.cpp @@ -0,0 +1,29 @@ +// Copyright (C) 2020 Intel Corporation +// SPDX-License-Identifier: Apache-2.0 +// + +#include +#include + +#include "ngraph_functions/builders.hpp" + +namespace ngraph { +namespace builder { + +std::shared_ptr makeRNNCell(const OutputVector& in, + const std::vector& WRB, + std::size_t hidden_size, + const std::vector& activations, + const std::vector& activations_alpha, + const std::vector& activations_beta, + float clip) { + std::vector