Enhance OpenVINO backend with view operations and new ops

ggml/src/ggml-openvino/ggml-decoder.cpp

@@ -1246,6 +1246,7 @@ std::string GgmlOvDecoder::compute_op_type(const ggml_tensor * node) {
         {GGML_OP_ACC,             "GGML_OP_ACC"            },
         {GGML_OP_ADD,             "GGML_OP_ADD"            },
         {GGML_OP_ADD1,            "GGML_OP_ADD1"           },
+        {GGML_OP_CONCAT,          "GGML_OP_CONCAT"         },
         {GGML_OP_CONT,            "GGML_OP_CONT"           },
         {GGML_OP_DIV,             "GGML_OP_DIV"            },
         {GGML_OP_DUP,             "GGML_OP_DUP"            },
@@ -1271,7 +1272,8 @@ std::string GgmlOvDecoder::compute_op_type(const ggml_tensor * node) {
         {GGML_OP_CLAMP,           "GGML_OP_CLAMP"          },
         {GGML_OP_PAD,             "GGML_OP_PAD"            },
         {GGML_OP_SSM_CONV,        "GGML_OP_SSM_CONV"       },
-        {GGML_OP_GATED_DELTA_NET, "GGML_OP_GATED_DELTA_NET"}
+        {GGML_OP_GATED_DELTA_NET, "GGML_OP_GATED_DELTA_NET"},
+        {GGML_OP_ARGSORT,         "GGML_OP_ARGSORT"        }
     };
     static const std::map<ggml_unary_op, std::string> unary_ops = {
         {GGML_UNARY_OP_ABS,         "GGML_UNARY_OP_ABS"        },
@@ -1285,6 +1287,7 @@ std::string GgmlOvDecoder::compute_op_type(const ggml_tensor * node) {
         {GGML_UNARY_OP_GELU,        "GGML_UNARY_OP_GELU"       },
         {GGML_UNARY_OP_GELU_QUICK,  "GGML_UNARY_OP_GELU_QUICK" },
         {GGML_UNARY_OP_SILU,        "GGML_UNARY_OP_SILU"       },
+        {GGML_UNARY_OP_SOFTPLUS,    "GGML_UNARY_OP_SOFTPLUS"   },
         {GGML_UNARY_OP_HARDSWISH,   "GGML_UNARY_OP_HARDSWISH"  },
         {GGML_UNARY_OP_HARDSIGMOID, "GGML_UNARY_OP_HARDSIGMOID"},
         {GGML_UNARY_OP_EXP,         "GGML_UNARY_OP_EXP"        },

ggml/src/ggml-openvino/ggml-openvino.cpp

@@ -1020,6 +1020,7 @@ static bool ggml_backend_openvino_device_supports_op(ggml_backend_dev_t dev, con
 
     static const std::set<ggml_op> supported_ops{GGML_OP_NONE,
                                                  GGML_OP_ADD,
+                                                 GGML_OP_CONCAT,
                                                  GGML_OP_DIV,
                                                  GGML_OP_MUL,
                                                  GGML_OP_MUL_MAT,
@@ -1047,6 +1048,7 @@ static bool ggml_backend_openvino_device_supports_op(ggml_backend_dev_t dev, con
     static const std::set<ggml_unary_op> supported_unary_ops{
         GGML_UNARY_OP_GELU,
         GGML_UNARY_OP_SILU,
+        GGML_UNARY_OP_SOFTPLUS,
         GGML_UNARY_OP_TANH,
     };
     static const std::set<ggml_glu_op> supported_glu_ops{
@@ -1061,11 +1063,6 @@ static bool ggml_backend_openvino_device_supports_op(ggml_backend_dev_t dev, con
             // GGML_LOG_WARN("OpenVINO backend does not support unary op %s\n", ggml_unary_op_name(ggml_get_unary_op(op)));
             return false;
         }
-        if (has_view_op_input(op)) {
-            // GGML_LOG_WARN("OpenVINO backend does not support unary op %s with view input\n",
-            //               ggml_unary_op_name(ggml_get_unary_op(op)));
-            return false;
-        }
         break;
     }
     case GGML_OP_GLU: {
@@ -1092,9 +1089,6 @@ static bool ggml_backend_openvino_device_supports_op(ggml_backend_dev_t dev, con
             return false;
         }
         static std::set<ggml_op> ops_not_support_view_input{
-            GGML_OP_GET_ROWS,
-            GGML_OP_RMS_NORM,
-            GGML_OP_NORM,
             GGML_OP_L2_NORM,
         };
         if (ops_not_support_view_input.find(op->op) != ops_not_support_view_input.end() && has_view_op_input(op)) {

ggml/src/ggml-openvino/openvino/op/argsort.cpp

@@ -0,0 +1,52 @@
+#include "../node_context.h"
+#include "../op_table.h"
+#include "../utils.h"
+#include "ggml.h"
+
+#include <openvino/frontend/exception.hpp>
+#include <openvino/op/constant.hpp>
+#include <openvino/op/squeeze.hpp>
+#include <openvino/op/topk.hpp>
+
+namespace ov {
+namespace frontend {
+namespace ggml {
+namespace op {
+
+OutputVector translate_argsort(const NodeContext & context) {
+    num_inputs_check(context, 1, 1);
+
+    auto input = process_view_input_new(context, 0);
+
+    const int32_t order = context.get_output_op_params()[0];
+
+    ov::op::v11::TopK::Mode mode;
+    switch (order) {
+        case GGML_SORT_ORDER_ASC:
+            mode = ov::op::v11::TopK::Mode::MIN;
+            break;
+        case GGML_SORT_ORDER_DESC:
+            mode = ov::op::v11::TopK::Mode::MAX;
+            break;
+        default:
+            FRONT_END_OP_CONVERSION_CHECK(false, "Unsupported GGML_OP_ARGSORT order: ", order);
+    }
+
+    auto k = std::make_shared<ov::op::v0::Squeeze>(get_dimensions(input.get_node_shared_ptr(), {3}),
+                                                   ov::op::v0::Constant::create(ov::element::i64, {1}, {0}));
+
+    auto topk = std::make_shared<ov::op::v11::TopK>(input,
+                                                    k,
+                                                    3,
+                                                    mode,
+                                                    ov::op::v11::TopK::SortType::SORT_VALUES,
+                                                    context.get_output_type(),
+                                                    false);
+
+    return rename_outputs_with_suffix({topk->output(1)}, context.get_name());
+}
+
+}  // namespace op
+}  // namespace ggml
+}  // namespace frontend
+}  // namespace ov

ggml/src/ggml-openvino/openvino/op/concat.cpp

@@ -0,0 +1,48 @@
+#include "../node_context.h"
+#include "../op_table.h"
+#include "../utils.h"
+
+#include <memory>
+#include <openvino/frontend/exception.hpp>
+#include <openvino/op/concat.hpp>
+#include <openvino/op/convert.hpp>
+
+namespace ov {
+namespace frontend {
+namespace ggml {
+namespace op {
+
+OutputVector translate_concat(const NodeContext & context) {
+    num_inputs_check(context, 2, 2);
+
+    const int32_t * op_params = context.get_output_op_params();
+    FRONT_END_CHECK_IMPLEMENTED(op_params != nullptr, "CONCAT requires output op params");
+
+    const auto output_shape = context.get_output_shape();
+    FRONT_END_CHECK_IMPLEMENTED(output_shape.rank().is_static(), "CONCAT requires static output rank");
+
+    const auto rank = output_shape.rank().get_length();
+    const int32_t ggml_dim = op_params[0];
+    FRONT_END_CHECK_IMPLEMENTED(ggml_dim >= 0 && ggml_dim < rank, "CONCAT axis is out of range");
+
+    auto input_0 = process_view_input_new(context, 0);
+    auto input_1 = process_view_input_new(context, 1);
+    const auto output_type = context.get_output_type();
+
+    if (input_0.get_element_type() != output_type) {
+        input_0 = std::make_shared<ov::op::v0::Convert>(input_0, output_type);
+    }
+    if (input_1.get_element_type() != output_type) {
+        input_1 = std::make_shared<ov::op::v0::Convert>(input_1, output_type);
+    }
+
+    const auto axis = static_cast<int64_t>(rank - 1 - ggml_dim);
+    auto res = std::make_shared<ov::op::v0::Concat>(OutputVector{input_0, input_1}, axis);
+
+    return rename_outputs_with_suffix({res}, context.get_name());
+}
+
+}  // namespace op
+}  // namespace ggml
+}  // namespace frontend
+}  // namespace ov

ggml/src/ggml-openvino/openvino/op/get_rows.cpp

@@ -18,16 +18,9 @@ namespace op {
 OutputVector translate_get_rows(const NodeContext & context) {
     num_inputs_check(context, 2, 2);
 
-    int op_case = context.get_op_case();
-
     Output<Node> res;
-    auto data = context.get_input(0);
-    auto indices = context.get_input(1);
-
-    if (op_case == 2) {
-        // The input comes from a VIEW
-        indices = process_view_input(context, 1);
-    }
+    auto data = process_view_input_new(context, 0);
+    auto indices = process_view_input_new(context, 1);
 
     // data[1,b,x,y] ind[1,1,b,x'] test-backend-ops case
     // data[x,y] ind[1,1,1,x'] normal case

ggml/src/ggml-openvino/openvino/op/unary_silu.cpp

@@ -14,7 +14,7 @@ namespace op {
 OutputVector translate_unary_silu(const NodeContext & context) {
     num_inputs_check(context, 1, 1);
 
-    auto input = context.get_input(0);
+    auto input = process_view_input_new(context, 0);
     auto sigmoid = std::make_shared<ov::op::v0::Sigmoid>(input);
     auto res = std::make_shared<ov::op::v1::Multiply>(input, sigmoid);
 

ggml/src/ggml-openvino/openvino/op/unary_softplus.cpp

@@ -0,0 +1,38 @@
+#include "../node_context.h"
+#include "../op_table.h"
+#include "../utils.h"
+
+#include <openvino/op/abs.hpp>
+#include <openvino/op/add.hpp>
+#include <openvino/op/constant.hpp>
+#include <openvino/op/exp.hpp>
+#include <openvino/op/log.hpp>
+#include <openvino/op/negative.hpp>
+#include <openvino/op/relu.hpp>
+
+namespace ov {
+namespace frontend {
+namespace ggml {
+namespace op {
+
+OutputVector translate_unary_softplus(const NodeContext & context) {
+    num_inputs_check(context, 1, 1);
+
+    auto input = process_view_input_new(context, 0);
+    const auto element_type = input.get_element_type();
+    auto one = ov::op::v0::Constant::create(element_type, ov::Shape{}, {1.0f});
+
+    auto positive = std::make_shared<ov::op::v0::Relu>(input);
+    auto abs = std::make_shared<ov::op::v0::Abs>(input);
+    auto neg_abs = std::make_shared<ov::op::v0::Negative>(abs);
+    auto exp_neg_abs = std::make_shared<ov::op::v0::Exp>(neg_abs);
+    auto log_term = std::make_shared<ov::op::v0::Log>(std::make_shared<ov::op::v1::Add>(one, exp_neg_abs));
+    auto res = std::make_shared<ov::op::v1::Add>(positive, log_term);
+
+    return rename_outputs_with_suffix({res}, context.get_name());
+}
+
+}  // namespace op
+}  // namespace ggml
+}  // namespace frontend
+}  // namespace ov

ggml/src/ggml-openvino/openvino/op_table.cpp

@@ -20,6 +20,7 @@ std::unordered_map<std::string, CreatorFunction> get_supported_ops() {
     return {
         {"GGML_OP_ADD",             op::translate_1to1_match_2_inputs<v1::Add>     },
         {"GGML_OP_ADD1",            op::translate_1to1_match_2_inputs<v1::Add>     },
+        {"GGML_OP_CONCAT",          op::translate_concat                           },
         {"GGML_OP_CONT",            op::translate_cont                             },
         {"GGML_OP_DIV",             op::translate_div                              },
         {"GGML_OP_GET_ROWS",        op::translate_get_rows                         },
@@ -35,10 +36,12 @@ std::unordered_map<std::string, CreatorFunction> get_supported_ops() {
         {"GGML_OP_ROPE",            op::translate_rope                             },
         {"GGML_OP_SCALE",           op::translate_scale                            },
         {"GGML_OP_SOFT_MAX",        op::translate_soft_max                         },
+        {"GGML_OP_ARGSORT",         op::translate_argsort                          },
         {"GGML_OP_SUB",             op::translate_1to1_match_2_inputs<v1::Subtract>},
         {"GGML_OP_TRANSPOSE",       op::translate_transpose                        },
         {"GGML_UNARY_OP_GELU",      op::translate_1to1_match_1_input<v7::Gelu>     },
         {"GGML_UNARY_OP_SILU",      op::translate_unary_silu                       },
+        {"GGML_UNARY_OP_SOFTPLUS",  op::translate_unary_softplus                   },
         {"GGML_UNARY_OP_TANH",      op::translate_1to1_match_1_input<v0::Tanh>     },
         {"GGML_OP_VIEW",            op::translate_view                             },
         {"GGML_GLU_OP_SWIGLU",      op::translate_glu_swiglu                       },

ggml/src/ggml-openvino/openvino/op_table.h

@@ -11,6 +11,7 @@ namespace op {
 #define GGML_OP_CONVERTER(op) OutputVector op(const NodeContext& context)
 
 GGML_OP_CONVERTER(translate_cont);
+GGML_OP_CONVERTER(translate_concat);
 GGML_OP_CONVERTER(translate_div);
 GGML_OP_CONVERTER(translate_get_rows);
 GGML_OP_CONVERTER(translate_mulmat);
@@ -24,13 +25,15 @@ GGML_OP_CONVERTER(translate_sum_rows);
 GGML_OP_CONVERTER(translate_rope);
 GGML_OP_CONVERTER(translate_scale);
 GGML_OP_CONVERTER(translate_unary_silu);
+GGML_OP_CONVERTER(translate_unary_softplus);
 GGML_OP_CONVERTER(translate_soft_max);
 GGML_OP_CONVERTER(translate_transpose);
 GGML_OP_CONVERTER(translate_view);
 GGML_OP_CONVERTER(translate_glu_swiglu);
 GGML_OP_CONVERTER(translate_glu_geglu);
 GGML_OP_CONVERTER(translate_set_rows);
 GGML_OP_CONVERTER(translate_cpy);
+GGML_OP_CONVERTER(translate_argsort);
 GGML_OP_CONVERTER(translate_flash_attn_ext);
 GGML_OP_CONVERTER(translate_clamp);
 GGML_OP_CONVERTER(translate_pad);

ggml/src/ggml-openvino/openvino/utils.h

@@ -87,7 +87,8 @@ OutputVector translate_1to1_match_2_inputs(const NodeContext& context) {
 template <typename T>
 OutputVector translate_1to1_match_1_input(const NodeContext& context) {
     num_inputs_check(context, 1, 1);
-    auto res = std::make_shared<T>(context.get_input(0));
+    auto input = process_view_input_new(context, 0);
+    auto res = std::make_shared<T>(input);
     return rename_outputs_with_suffix({res}, context.get_name());
 }
 }  // namespace op