[GPU] LSTMSequence and LSTMCell optimization

src/plugins/intel_gpu/include/intel_gpu/primitives/lstm.hpp

@@ -8,31 +8,18 @@
 #include <vector>
 #include <algorithm>
 #include "intel_gpu/graph/serialization/activation_serializer.hpp"
+#include "rnn.hpp"
 
-namespace cldnn {
 
-/// @brief Weights orders
-/// @details Specifies the order in which the weights are concatenated.
-/// e.g. [i, o, f, z] : [input, output, forget, block]
-/// ONNX order: iofz
-/// Caffe order: ifoz
-/// pyTorch order: izof
-/// OV order: fizo
-enum class lstm_weights_order {
-    iofz,
-    ifoz,
-    izof,
-    fizo
-};
+namespace cldnn {
 
-struct lstm_elt : public primitive_base<lstm_elt> {
+struct lstm_elt : public RNNParams<lstm_elt> {
     CLDNN_DECLARE_PRIMITIVE(lstm_elt)
-
-    lstm_elt() : primitive_base("", {}), clip(0), input_forget(0), offset_order(lstm_weights_order::iofz), direction(0) {}
-
     using vec_activation = std::vector<activation_func>;
     using vec_activation_param = std::vector<activation_additional_params>;
-
+    using RNNParams::RNNParams;
+    lstm_elt() : RNNParams() {}
+    lstm_elt(const lstm_elt&) = default;
     /// @brief Constructs lstm layer.
     /// @param id This primitive id.
     /// @param input input primitive id.
@@ -42,7 +29,7 @@ struct lstm_elt : public primitive_base<lstm_elt> {
     /// @param offset_order. Order of the concatenated weights, recurrent, and bias. ONNX default is iofz [input, output, forget, block].
     /// @param direction default = 0, bidirectional = 1.
     lstm_elt(const primitive_id& id,
-             const input_info& input,
+             const input_info& x,
              const primitive_id& cell = "",
              const float clip = 0,
              const bool input_forget = 0,
@@ -52,95 +39,17 @@ struct lstm_elt : public primitive_base<lstm_elt> {
              const std::vector<activation_additional_params> activation_params = {},
              const lstm_weights_order offset_order = lstm_weights_order::iofz,
              const uint32_t direction = 0)
-        : primitive_base(id, {input}),
-          cell(cell),
-          clip(clip),
-          input_forget(input_forget),
-          activations(activations),
-          activation_params(activation_params),
-          offset_order(offset_order),
-          direction(direction) {}
-
-    /// @brief Primitive id containing the initial value of the cell state data.
-    primitive_id cell;
-    /// @brief Cell clip threshold T. It is applied to the input of activations [-T, T]. No clip is applied if it is not specified.
-    float clip;
-    /// @brief Couple the input and forget gates if input_forget is 1. Default is 0.
-    bool input_forget;
-    /// @brief A list of 3 activation functions for the input, output, forget, cell, and hidden.
-    std::vector<activation_func> activations;
-    /// @brief Optional scaling values used by some activation functions. The values are consumed in the order of activation functions.
-    std::vector<activation_additional_params> activation_params;
-    /// @brief Weights, recurrent weights, and biases order. [iofz] : ONNX, [ifoz] : Caffe
-    lstm_weights_order offset_order;
-    /// @brief direction default = 0, bidirectional = 1.
-    uint32_t direction;
-
-    size_t hash() const override {
-        size_t seed = primitive::hash();
-        seed = hash_combine(seed, clip);
-        seed = hash_combine(seed, input_forget);
-        seed = hash_range(seed, activations.begin(), activations.end());
-        for (auto& act_param : activation_params) {
-            seed = hash_combine(seed, act_param.a);
-            seed = hash_combine(seed, act_param.b);
-        }
-        seed = hash_combine(seed, offset_order);
-        seed = hash_combine(seed, direction);
-        seed = hash_combine(seed, cell.empty());
-        return seed;
-    }
-
-    bool operator==(const primitive& rhs) const override {
-        if (!compare_common_params(rhs))
-            return false;
-
-        auto rhs_casted = downcast<const lstm_elt>(rhs);
-
-        bool act_params_eq = activation_params.size() == rhs_casted.activation_params.size();
-        for (size_t i = 0; i < activation_params.size(); ++i) {
-            act_params_eq &= activation_params[i].a == rhs_casted.activation_params[i].a &&
-                             activation_params[i].b == rhs_casted.activation_params[i].b;
+        : RNNParams(id, x, {}, cell, {}, {}, {}, {}, "", "", clip, input_forget, activations, activation_params, offset_order,
+          direction == 0 ? ov::op::RecurrentSequenceDirection::FORWARD : ov::op::RecurrentSequenceDirection::REVERSE) {
+        if (!cell.empty())
+            input.pop_back();
         }
 
-        #define cmp_fields(name) name == rhs_casted.name
-        return act_params_eq &&
-               cmp_fields(clip) &&
-               cmp_fields(input_forget) &&
-               cmp_fields(activations) &&
-               cmp_fields(offset_order) &&
-               cmp_fields(direction) &&
-               cmp_fields(cell.empty());
-        #undef cmp_fields
-    }
-
-    void save(BinaryOutputBuffer& ob) const override {
-        primitive_base<lstm_elt>::save(ob);
-        ob << cell;
-        ob << clip;
-        ob << input_forget;
-        ob << activations;
-        ob << activation_params;
-        ob << make_data(&offset_order, sizeof(lstm_weights_order));
-        ob << direction;
-    }
-
-    void load(BinaryInputBuffer& ib) override {
-        primitive_base<lstm_elt>::load(ib);
-        ib >> cell;
-        ib >> clip;
-        ib >> input_forget;
-        ib >> activations;
-        ib >> activation_params;
-        ib >> make_data(&offset_order, sizeof(lstm_weights_order));
-        ib >> direction;
-    }
-
 protected:
     std::vector<input_info> get_dependencies() const override {
         std::vector<input_info> ret;
-        if (!cell.empty())
-            ret.push_back(cell);
+        if (!initial_cell_state.pid.empty())
+            ret.push_back(initial_cell_state);
         return ret;
     }
 };

src/plugins/intel_gpu/include/intel_gpu/primitives/lstm_cell.hpp

@@ -0,0 +1,24 @@
+// Copyright (C) 2018-2024 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+#include "primitive.hpp"
+#include "activation.hpp"
+#include <vector>
+#include <algorithm>
+#include "intel_gpu/graph/serialization/activation_serializer.hpp"
+#include "rnn.hpp"
+
+
+namespace cldnn {
+
+struct lstm_cell : public RNNParams<lstm_cell> {
+    CLDNN_DECLARE_PRIMITIVE(lstm_cell)
+    using vec_activation = std::vector<activation_func>;
+    using vec_activation_param = std::vector<activation_additional_params>;
+    using RNNParams::RNNParams;
+    lstm_cell(const lstm_cell&) = default;
+    lstm_cell() : RNNParams() {}
+};
+}  // namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/primitives/rnn.hpp

@@ -0,0 +1,203 @@
+// Copyright (C) 2018-2024 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+#include "primitive.hpp"
+#include "activation.hpp"
+#include <vector>
+#include <algorithm>
+#include <string>
+#include "intel_gpu/graph/serialization/activation_serializer.hpp"
+
+namespace cldnn {
+
+/// @brief Weights orders
+/// @details Specifies the order in which the weights are concatenated.
+/// e.g. [i, o, f, z] : [input, output, forget, block]
+/// ONNX order: iofz
+/// Caffe order: ifoz
+/// pyTorch order: izof
+/// OV order: fizo
+enum class lstm_weights_order {
+    iofz,
+    ifoz,
+    izof,
+    fizo
+};
+
+template <typename PType>
+struct RNNParams : public primitive_base<PType> {
+    RNNParams() : primitive_base<PType>("", {}) {}
+    RNNParams(const RNNParams&) = default;
+    RNNParams(const primitive_id& id,
+              const input_info& x,
+              const input_info& initial_hidden_state,
+              const input_info& initial_cell_state,
+              const input_info& W,
+              const input_info& R,
+              const input_info& B,
+              const input_info& seq_lenghts,
+              const primitive_id& out1_prim_id = "",
+              const primitive_id& out2_prim_id = "",
+              const float clip = 0,
+              bool input_forget = false,
+              const std::vector<activation_func>& activations = {activation_func::logistic,
+                                                                activation_func::hyperbolic_tan,
+                                                                activation_func::hyperbolic_tan},
+              const std::vector<activation_additional_params>& activation_params = {},
+              const lstm_weights_order& offset_order = lstm_weights_order::iofz,
+              const ov::op::RecurrentSequenceDirection direction = ov::op::RecurrentSequenceDirection::FORWARD,
+              const padding& output_padding = padding(),
+              const int num_outputs = 1)
+        : primitive_base<PType>(id, {x}, num_outputs, {optional_data_type()}, {output_padding}),
+        x(x),
+        initial_hidden_state(initial_hidden_state),
+        initial_cell_state(initial_cell_state),
+        W(W),
+        R(R),
+        B(B),
+        seq_lenghts(seq_lenghts),
+        out1_prim_id(out1_prim_id),
+        out2_prim_id(out2_prim_id),
+        clip(clip),
+        input_forget(input_forget),
+        activations(activations),
+        activation_params(activation_params),
+        offset_order(offset_order),
+        direction(direction) {
+        std::vector<std::string> pids{initial_hidden_state.pid, initial_cell_state.pid, W.pid, R.pid, B.pid, seq_lenghts.pid, out1_prim_id, out2_prim_id};
+        for (auto pid : pids) {
+            if (!pid.empty()) {
+                primitive_base<PType>::input.push_back(pid);
+            }
+        }
+    }
+
+    input_info x;
+    input_info initial_hidden_state;
+    input_info initial_cell_state;
+    input_info W;
+    input_info R;
+    input_info B;
+    input_info seq_lenghts;
+    primitive_id out1_prim_id;
+    primitive_id out2_prim_id;
+    /// @brief Cell clip threshold T. It is applied to the input of activations [-T, T]. No clip is applied if it is not specified.
+    float clip;
+    bool input_forget;
+    /// @brief A list of 3 activation functions for the input, output, forget, cell, and hidden.
+    std::vector<activation_func> activations;
+    /// @brief Optional scaling values used by some activation functions. The values are consumed in the order of activation functions.
+    std::vector<activation_additional_params> activation_params;
+    /// @brief Weights, recurrent weights, and biases order. [iofz] : ONNX, [ifoz] : Caffe
+    lstm_weights_order offset_order;
+    /// @brief direction of LSTMSequence - only FORWARD or REVERSE, currently BIDIRECTIONAL not supported
+    ov::op::RecurrentSequenceDirection direction;
+
+    int num_directions() const {
+        return direction == ov::op::RecurrentSequenceDirection::BIDIRECTIONAL ? 2 : 1;
+    }
+
+    size_t hash() const override {
+        size_t seed = primitive::hash();
+        seed = hash_combine(seed, x.pid);
+        seed = hash_combine(seed, initial_hidden_state.pid);
+        seed = hash_combine(seed, initial_cell_state.pid);
+        seed = hash_combine(seed, seq_lenghts.pid);
+        seed = hash_combine(seed, W.pid);
+        seed = hash_combine(seed, R.pid);
+        seed = hash_combine(seed, B.pid);
+        seed = hash_combine(seed, out1_prim_id);
+        seed = hash_combine(seed, out2_prim_id);
+        seed = hash_combine(seed, clip);
+        seed = hash_range(seed, activations.begin(), activations.end());
+        for (auto& act_param : activation_params) {
+            seed = hash_combine(seed, act_param.a);
+            seed = hash_combine(seed, act_param.b);
+        }
+        seed = hash_combine(seed, offset_order);
+        seed = hash_combine(seed, direction);
+        return seed;
+    }
+
+    bool operator==(const primitive& rhs) const override {
+        if (!primitive::compare_common_params(rhs))
+            return false;
+
+        auto rhs_casted = downcast<const PType>(rhs);
+        bool act_params_eq = activation_params.size() == rhs_casted.activation_params.size();
+        for (size_t i = 0; i < activation_params.size(); ++i) {
+            act_params_eq &= activation_params[i].a == rhs_casted.activation_params[i].a &&
+                             activation_params[i].b == rhs_casted.activation_params[i].b;
+        }
+
+        #define cmp_fields(name) name == rhs_casted.name
+        return act_params_eq &&
+               cmp_fields(x) &&
+               cmp_fields(initial_hidden_state) &&
+               cmp_fields(initial_cell_state) &&
+               cmp_fields(seq_lenghts) &&
+               cmp_fields(W) &&
+               cmp_fields(R) &&
+               cmp_fields(B) &&
+               cmp_fields(out1_prim_id) &&
+               cmp_fields(out2_prim_id) &&
+               cmp_fields(clip) &&
+               cmp_fields(activations) &&
+               cmp_fields(offset_order) &&
+               cmp_fields(direction);
+        #undef cmp_fields
+    }
+
+    void save(BinaryOutputBuffer& ob) const override {
+        primitive_base<PType>::save(ob);
+        ob << x;
+        ob << initial_hidden_state;
+        ob << initial_cell_state;
+        ob << W;
+        ob << R;
+        ob << B;
+        ob << seq_lenghts;
+        ob << out1_prim_id;
+        ob << out2_prim_id;
+        ob << clip;
+        ob << activations;
+        ob << activation_params;
+        ob << make_data(&offset_order, sizeof(lstm_weights_order));
+        ob << make_data(&direction, sizeof(ov::op::RecurrentSequenceDirection));
+    }
+
+    void load(BinaryInputBuffer& ib) override{
+        primitive_base<PType>::load(ib);
+        ib >> x;
+        ib >> initial_hidden_state;
+        ib >> initial_cell_state;
+        ib >> W;
+        ib >> R;
+        ib >> B;
+        ib >> seq_lenghts;
+        ib >> out1_prim_id;
+        ib >> out2_prim_id;
+        ib >> clip;
+        ib >> activations;
+        ib >> activation_params;
+        ib >> make_data(&offset_order, sizeof(lstm_weights_order));
+        ib >> make_data(&direction, sizeof(ov::op::RecurrentSequenceDirection));
+    }
+};
+
+struct lstm_seq : public RNNParams<lstm_seq> {
+    CLDNN_DECLARE_PRIMITIVE(lstm_seq)
+    using vec_activation = std::vector<activation_func>;
+    using vec_activation_param = std::vector<activation_additional_params>;
+    using RNNParams::RNNParams;
+    lstm_seq() : RNNParams() {
+        weights = W.pid;
+        input = x.pid;
+    }
+    lstm_seq(const lstm_seq&) = default;
+    primitive_id input;
+    primitive_id weights;
+};
+} //namespace cldnn

src/plugins/intel_gpu/include/intel_gpu/runtime/internal_properties.hpp

@@ -56,6 +56,7 @@ static constexpr Property<size_t, PropertyMutability::RW> max_dynamic_batch{"DYN
 static constexpr Property<bool, PropertyMutability::RW> nv12_two_inputs{"GPU_NV12_TWO_INPUTS"};
 static constexpr Property<float, PropertyMutability::RW> buffers_preallocation_ratio{"GPU_BUFFERS_PREALLOCATION_RATIO"};
 static constexpr Property<size_t, PropertyMutability::RW> max_kernels_per_batch{"GPU_MAX_KERNELS_PER_BATCH"};
+static constexpr Property<bool, PropertyMutability::RW> use_onednn{"USE_ONEDNN"};
 
 }  // namespace intel_gpu
 }  // namespace ov