whispercpp 1.3.7 → 1.3.8

data/ext/sources/ggml/src/ggml-openvino/openvino/op/mulmat.cpp

@@ -30,17 +30,16 @@ OutputVector translate_mulmat(const NodeContext & context) {
     int op_case = context.get_op_case();
 
     ov::Output<Node> res;
-    ov::Output<ov::Node> B = context.get_input(0);
-    ov::Output<ov::Node> A = context.get_input(1);
-
-    bool transpose_b = true;
-    if (op_case == 2) {
-        B = B.get_node_shared_ptr()->input_value(0);
-        transpose_b = false;
-    } else if (op_case == 3) {
+    ov::Output<ov::Node> B;
+    ov::Output<ov::Node> A;
+    if (op_case == 3) {
         B = process_view_input(context, 0);
         A = process_view_input(context, 1);
+    } else {
+        B = process_view_input_new(context, 0);
+        A = process_view_input_new(context, 1);
     }
+
     if (A.get_element_type() != B.get_element_type()) {
         B = std::make_shared<ov::op::v0::Convert>(context.get_input(0), context.get_input_type(1));
     }
@@ -55,6 +54,7 @@ OutputVector translate_mulmat(const NodeContext & context) {
     auto batch_small = A_batch_larger ? B_batch : A_batch;
 
     Output<Node> Z = A_batch_larger ? B : A;
+    auto Z_shape = A_batch_larger ? B_shape : A_shape;
     int64_t factor = batch_large / batch_small;
     if (factor > 1 && batch_small > 1) {
         auto batch_large_node = ov::op::v0::Constant::create(ov::element::i64, {1}, std::vector<int64_t>{batch_large});
@@ -67,7 +67,11 @@ OutputVector translate_mulmat(const NodeContext & context) {
         auto broadcast_shape = ov::op::v0::Constant::create(
             ov::element::i64, {5}, {(int64_t) 1, (int64_t) 1, factor, (int64_t) 1, (int64_t) 1});
         auto new_Z_shape = ov::op::v0::Constant::create(ov::element::i64, {4},
-                                                        {(int64_t) 0, batch_large, (int64_t) -1, (int64_t) A_shape[3]});
+                                                        {(int64_t) 0, batch_large, (int64_t) -1, (int64_t) Z_shape[3]});
+        if (op_case == 2) {
+            new_Z_shape = ov::op::v0::Constant::create(ov::element::i64, {4},
+                                                       {(int64_t) 0, batch_large, (int64_t) Z_shape[2], (int64_t) -1});
+        }
 
         auto Z_broadcasted = std::make_shared<ov::op::v3::Broadcast>(Z_unsqueezed, broadcast_shape,
                                                                      ov::op::BroadcastType::BIDIRECTIONAL);
@@ -79,8 +83,14 @@ OutputVector translate_mulmat(const NodeContext & context) {
         A = Z;
     }
 
+    bool transpose_b = true;
     res = std::make_shared<ov::op::v0::MatMul>(A, B, false, transpose_b);
 
+    const auto output_type = context.get_output_type();
+    if (res.get_element_type() != output_type) {
+        res = std::make_shared<ov::op::v0::Convert>(res, output_type);
+    }
+
     return rename_outputs_with_suffix({res}, context.get_name());
 }
 

data/ext/sources/ggml/src/ggml-openvino/openvino/op/norm.cpp

@@ -0,0 +1,58 @@
+#include "../node_context.h"
+#include "../op_table.h"
+#include "../utils.h"
+
+#include <memory>
+#include <openvino/op/add.hpp>
+#include <openvino/op/constant.hpp>
+#include <openvino/op/divide.hpp>
+#include <openvino/op/multiply.hpp>
+#include <openvino/op/power.hpp>
+#include <openvino/op/reduce_mean.hpp>
+#include <openvino/op/sqrt.hpp>
+#include <openvino/op/subtract.hpp>
+
+namespace ov {
+namespace frontend {
+namespace ggml {
+namespace op {
+
+OutputVector translate_norm(const NodeContext & context) {
+    num_inputs_check(context, 1, 1);
+
+    auto input_node = process_view_input_new(context, 0);
+
+    // Step 1: Calculate mean along the last dimension
+    // mean = reduce_mean(input, axis=-1, keepdims=true)
+    auto mean = std::make_shared<ov::op::v1::ReduceMean>(
+        input_node, ov::op::v0::Constant::create(ov::element::i64, ov::Shape{1}, {-1}), true);
+
+    // Step 2: Calculate (input - mean)
+    auto centered = std::make_shared<ov::op::v1::Subtract>(input_node, mean);
+
+    // Step 3: Calculate squared differences (input - mean)^2
+    auto squared = std::make_shared<ov::op::v1::Power>(
+        centered, ov::op::v0::Constant::create(ov::element::f32, ov::Shape{1}, {2.0f}));
+
+    // Step 4: Calculate variance = mean((input - mean)^2)
+    auto variance = std::make_shared<ov::op::v1::ReduceMean>(
+        squared, ov::op::v0::Constant::create(ov::element::i64, ov::Shape{1}, {-1}), true);
+
+    // Step 5: Get epsilon from op_params
+    float eps;
+    memcpy(&eps, context.get_output_op_params(), sizeof(float));
+
+    // Step 6: Calculate std = sqrt(variance + eps)
+    auto std_dev = std::make_shared<ov::op::v0::Sqrt>(std::make_shared<ov::op::v1::Add>(
+        variance, ov::op::v0::Constant::create(ov::element::f32, ov::Shape{1}, {eps})));
+
+    // Step 7: Normalize: output = (input - mean) / std
+    auto res = std::make_shared<ov::op::v1::Divide>(centered, std_dev);
+
+    return rename_outputs_with_suffix({res}, context.get_name());
+}
+
+}  // namespace op
+}  // namespace ggml
+}  // namespace frontend
+}  // namespace ov

data/ext/sources/ggml/src/ggml-openvino/openvino/op/pad.cpp

@@ -0,0 +1,95 @@
+#include "../op_table.h"
+#include "../utils.h"
+
+#include <array>
+#include <cstdint>
+#include <openvino/op/constant.hpp>
+#include <openvino/op/gather.hpp>
+#include <openvino/op/pad.hpp>
+#include <openvino/op/reshape.hpp>
+#include <openvino/op/shape_of.hpp>
+#include <vector>
+
+namespace ov {
+namespace frontend {
+namespace ggml {
+namespace op {
+
+namespace {
+
+ov::Output<ov::Node> translate_circular_pad(ov::Output<ov::Node> input,
+                                            const std::array<int32_t, 8> & pads,
+                                            const ov::Shape & input_shape) {
+    ov::Output<ov::Node> result = input;
+
+    const std::array<int32_t, 4> pads_begin = {pads[6], pads[4], pads[2], pads[0]};
+    const std::array<int32_t, 4> pads_end = {pads[7], pads[5], pads[3], pads[1]};
+
+    for (size_t axis = 0; axis < input_shape.size(); ++axis) {
+        const int64_t input_dim = static_cast<int64_t>(input_shape[axis]);
+        const int64_t pad_begin = pads_begin[axis];
+        const int64_t pad_end = pads_end[axis];
+
+        if (pad_begin == 0 && pad_end == 0) {
+            continue;
+        }
+
+        FRONT_END_CHECK_IMPLEMENTED(input_dim > 0, "Circular PAD requires static non-zero input dimensions");
+
+        std::vector<int64_t> indices(static_cast<size_t>(input_dim + pad_begin + pad_end));
+        for (int64_t index = 0; index < static_cast<int64_t>(indices.size()); ++index) {
+            int64_t wrapped = (index - pad_begin) % input_dim;
+            if (wrapped < 0) {
+                wrapped += input_dim;
+            }
+            indices[static_cast<size_t>(index)] = wrapped;
+        }
+
+        auto gather_indices = ov::op::v0::Constant::create(ov::element::i64, {indices.size()}, indices);
+        auto gather_axis = ov::op::v0::Constant::create(ov::element::i64, ov::Shape{}, {axis});
+        result = std::make_shared<ov::op::v8::Gather>(result, gather_indices, gather_axis);
+    }
+
+    return result;
+}
+
+}  // namespace
+
+OutputVector translate_pad(const NodeContext & context) {
+    num_inputs_check(context, 1, 1);
+
+    auto input = process_view_input_new(context, 0);
+    if (context.get_input_shape(0) == context.get_output_shape()) {
+        auto input_shape = std::make_shared<ov::op::v3::ShapeOf>(input);
+        auto res = std::make_shared<ov::op::v1::Reshape>(input, input_shape, false);
+        return rename_outputs_with_suffix({res}, context.get_name());
+    }
+
+    const int32_t * op_params = context.get_output_op_params();
+    FRONT_END_CHECK_IMPLEMENTED(op_params != nullptr, "PAD requires output op params");
+
+    const std::array<int32_t, 8> pads = {op_params[0], op_params[1], op_params[2], op_params[3],
+                                         op_params[4], op_params[5], op_params[6], op_params[7]};
+    const bool circular = op_params[8] != 0;
+
+    if (circular) {
+        auto res = translate_circular_pad(input, pads, context.get_input_shape(0).to_shape());
+        return rename_outputs_with_suffix({res}, context.get_name());
+    }
+
+    const std::vector<int64_t> pads_begin = {pads[6], pads[4], pads[2], pads[0]};
+    const std::vector<int64_t> pads_end = {pads[7], pads[5], pads[3], pads[1]};
+
+    auto pads_begin_node = ov::op::v0::Constant::create(ov::element::i64, {pads_begin.size()}, pads_begin);
+    auto pads_end_node = ov::op::v0::Constant::create(ov::element::i64, {pads_end.size()}, pads_end);
+    auto pad_value = ov::op::v0::Constant::create(context.get_input_type(0), ov::Shape{}, {0});
+    auto res =
+        std::make_shared<ov::op::v1::Pad>(input, pads_begin_node, pads_end_node, pad_value, ov::op::PadMode::CONSTANT);
+
+    return rename_outputs_with_suffix({res}, context.get_name());
+}
+
+}  // namespace op
+}  // namespace ggml
+}  // namespace frontend
+}  // namespace ov

data/ext/sources/ggml/src/ggml-openvino/openvino/op/permute.cpp

@@ -12,6 +12,7 @@
 #include <openvino/op/reshape.hpp>
 #include <openvino/op/slice.hpp>
 #include <openvino/op/transpose.hpp>
+#include <vector>
 
 namespace ov {
 namespace frontend {
@@ -22,16 +23,33 @@ OutputVector translate_permute(const NodeContext & context) {
     num_inputs_check(context, 1, 1);
 
     int op_case = context.get_op_case();
-    FRONT_END_CHECK_IMPLEMENTED(op_case == 1 || op_case == 2 || op_case == 3 || op_case == 4,
-                                "Unsupported PERMUTE case");
+    FRONT_END_CHECK_IMPLEMENTED(op_case != 0, "Unsupported PERMUTE case");
+    // op_case 1 is trivial permute
+    // op_case 2 is to permute Q. It has a preceding VIEW that reshapes Q to restore the sequqence dimension
+    // op_case 3 4 it to permute KV cache in the default layout
+    // op_case 5 6 is to permute V cache when `-fa off`, where v_trans=true
 
     ov::Output<Node> res;
-    auto src = context.get_input(0);
-    auto perm = ov::op::v0::Constant::create(ov::element::i64, {4}, {0, 2, 1, 3});
+    ov::Output<Node> src;
+    if (op_case == 3 || op_case == 4 || op_case == 5 || op_case == 6) {
+        src = context.get_input(0);
+    } else {
+        src = process_view_input_new(context, 0);
+    }
+    std::vector<int64_t> perm_values{0, 2, 1, 3};
+    const int32_t * op_params = context.get_output_op_params();
+    if (op_params != nullptr) {
+        for (size_t input_axis = 0; input_axis < perm_values.size(); ++input_axis) {
+            const size_t output_axis = static_cast<size_t>(op_params[input_axis]);
+            perm_values[perm_values.size() - 1 - output_axis] =
+                static_cast<int64_t>(perm_values.size() - 1 - input_axis);
+        }
+    }
+    auto perm = ov::op::v0::Constant::create(ov::element::i64, {4}, perm_values);
 
     if (op_case == 1 || context.is_stateful()) {
         res = std::make_shared<ov::op::v1::Transpose>(src, perm);
-    } else if (op_case == 4) {
+    } else if (op_case == 2) {
         auto output_shape = context.get_output_shape().to_shape();
         auto n_heads = ov::op::v0::Constant::create(ov::element::i64, {1}, {output_shape[1]});
         auto head_size = ov::op::v0::Constant::create(ov::element::i64, {1}, {output_shape[3]});
@@ -54,13 +72,17 @@ OutputVector translate_permute(const NodeContext & context) {
         auto output_shape = context.get_output_shape().to_shape();
         int64_t head_size = output_shape[3];
         int64_t n_heads = output_shape[1];
+        if (op_case == 5 || op_case == 6) {
+            head_size = output_shape[2];
+            n_heads = output_shape[1];
+        }
         int64_t ctx_per_seq = cache_shape[2].is_static() ? cache_shape[2].get_length() : -1;
         int64_t n_seq = cache_shape[1].get_length();
 
         Output<Node> attention_size;
         if (!context.has_input("attention_size")) {
             attention_size = ov::op::v0::Constant::create(ov::element::i64, {1}, {output_shape[2]});
-        } else if (op_case == 2) {
+        } else if (op_case == 3 || op_case == 5) {
             attention_size = context.get_input("attention_size");
         } else {
             attention_size = context.get_input("attention_size_swa");
@@ -80,18 +102,41 @@ OutputVector translate_permute(const NodeContext & context) {
             seq_active_end = ov::op::v0::Constant::create(ov::element::i64, {1}, {seq_active_end_val});
         }
 
-        // 1. reshape to [n_seq, ctx_per_seq, n_heads, head_size]
+        // 1. reshape to [n_seq, ctx_per_seq, n_heads, head_size] (for `-fa off` [n_seq, n_heads, head_size, ctx_per_seq])
         // 2. slice out the active sequences
         // 3. slice out the attention part in each sequence
-        // 4. permute
+        // 4. permute (skip for `-fa off`)
         auto zero = ov::op::v0::Constant::create(ov::element::i64, {1}, {0});
         auto one = ov::op::v0::Constant::create(ov::element::i64, {1}, {1});
 
-        auto src_reshaped = std::make_shared<ov::op::v1::Reshape>(
-            src, ov::op::v0::Constant::create(ov::element::i64, {4}, {n_seq, ctx_per_seq, n_heads, head_size}), false);
-        auto slice1 = std::make_shared<ov::op::v8::Slice>(src_reshaped, seq_active_start, seq_active_end, one, zero);
-        auto slice2 = std::make_shared<ov::op::v8::Slice>(slice1, zero, attention_size, one, one);
-        res = std::make_shared<ov::op::v1::Transpose>(slice2, perm);
+        if (op_case == 3 || op_case == 4) {
+            auto src_reshaped = std::make_shared<ov::op::v1::Reshape>(
+                src, ov::op::v0::Constant::create(ov::element::i64, {4}, {n_seq, ctx_per_seq, n_heads, head_size}),
+                false);
+            ov::Output<ov::Node> after_seq_slice;
+            if (n_seq == 1) {
+                after_seq_slice = src_reshaped;
+            } else {
+                after_seq_slice =
+                    std::make_shared<ov::op::v8::Slice>(src_reshaped, seq_active_start, seq_active_end, one, zero);
+            }
+            auto slice2 = std::make_shared<ov::op::v8::Slice>(after_seq_slice, zero, attention_size, one, one);
+            res = std::make_shared<ov::op::v1::Transpose>(slice2, perm);
+        } else {
+            auto three = ov::op::v0::Constant::create(ov::element::i64, {1}, {3});
+            auto src_reshaped = std::make_shared<ov::op::v1::Reshape>(
+                src, ov::op::v0::Constant::create(ov::element::i64, {4}, {n_seq, n_heads, head_size, ctx_per_seq}),
+                false);
+            ov::Output<ov::Node> after_seq_slice;
+            if (n_seq == 1) {
+                after_seq_slice = src_reshaped;
+            } else {
+                after_seq_slice =
+                    std::make_shared<ov::op::v8::Slice>(src_reshaped, seq_active_start, seq_active_end, one, zero);
+            }
+            auto slice2 = std::make_shared<ov::op::v8::Slice>(after_seq_slice, zero, attention_size, one, three);
+            res = slice2;
+        }
     }
     return rename_outputs_with_suffix({res}, context.get_name());
 }

data/ext/sources/ggml/src/ggml-openvino/openvino/op/repeat.cpp

@@ -0,0 +1,74 @@
+#include "../node_context.h"
+#include "../op_table.h"
+#include "../utils.h"
+#include "ggml.h"
+
+#include <memory>
+#include <openvino/op/broadcast.hpp>
+#include <openvino/op/constant.hpp>
+#include <openvino/op/divide.hpp>
+#include <openvino/op/shape_of.hpp>
+#include <openvino/op/tile.hpp>
+#include <vector>
+
+namespace ov {
+namespace frontend {
+namespace ggml {
+namespace op {
+
+// GGML_OP_REPEAT tiles src[0] to fill the destination shape. Every destination
+// dimension is an integer multiple of the corresponding source dimension.
+OutputVector translate_repeat(const NodeContext & context) {
+    num_inputs_check(context, 1, 2);
+
+    auto input = process_view_input_new(context, 0);
+
+    const auto input_shape = context.get_input_shape(0);
+    const auto output_shape = context.get_output_shape();
+
+    if (input_shape.rank().is_static() && output_shape.rank().is_static() &&
+        input_shape.rank() == output_shape.rank()) {
+        const auto rank = static_cast<size_t>(input_shape.rank().get_length());
+        std::vector<int64_t> repeats(rank, 1);
+        bool all_static = true;
+
+        for (size_t axis = 0; axis < rank; ++axis) {
+            if (!input_shape[axis].is_static() || !output_shape[axis].is_static()) {
+                all_static = false;
+                break;
+            }
+
+            const int64_t input_dim = input_shape[axis].get_length();
+            const int64_t output_dim = output_shape[axis].get_length();
+
+            FRONT_END_OP_CONVERSION_CHECK(input_dim > 0 && output_dim > 0 && output_dim % input_dim == 0,
+                                          "REPEAT input shape ", input_shape, " cannot tile to match ", output_shape);
+
+            repeats[axis] = output_dim / input_dim;
+        }
+
+        if (all_static) {
+            auto repeats_node = ov::op::v0::Constant::create(ov::element::i64, {repeats.size()}, repeats);
+            ov::Output<ov::Node> res = std::make_shared<ov::op::v0::Tile>(input, repeats_node);
+            return rename_outputs_with_suffix({res}, context.get_name());
+        }
+    }
+
+    // Dynamic fallback: tile by the ratio of output to input shape.
+    auto input_shape_node = std::make_shared<ov::op::v3::ShapeOf>(input, ov::element::i64);
+    std::shared_ptr<ov::Node> target_shape_node;
+    if (output_shape.rank().is_static() && output_shape.is_static()) {
+        target_shape_node =
+            ov::op::v0::Constant::create(ov::element::i64, {output_shape.to_shape().size()}, output_shape.to_shape());
+    } else {
+        target_shape_node = std::make_shared<ov::op::v3::ShapeOf>(context.get_input(1), ov::element::i64);
+    }
+    auto repeats_node = std::make_shared<ov::op::v1::Divide>(target_shape_node, input_shape_node);
+    ov::Output<ov::Node> res = std::make_shared<ov::op::v0::Tile>(input, repeats_node);
+    return rename_outputs_with_suffix({res}, context.get_name());
+}
+
+}  // namespace op
+}  // namespace ggml
+}  // namespace frontend
+}  // namespace ov

data/ext/sources/ggml/src/ggml-openvino/openvino/op/reshape.cpp

@@ -10,7 +10,6 @@
 #include <openvino/op/concat.hpp>
 #include <openvino/op/constant.hpp>
 #include <openvino/op/reshape.hpp>
-#include <stdexcept>
 #include <vector>
 
 namespace ov {
@@ -20,7 +19,8 @@ namespace op {
 
 OutputVector translate_reshape(const NodeContext & context) {
     num_inputs_check(context, 1, 1);
-    if (context.get_input_shape(0) == context.get_output_shape()) {
+    if (context.get_input(0).get_partial_shape().is_static() &&
+        context.get_input_shape(0) == context.get_output_shape()) {
         return {context.get_input(0)};
     }
 
@@ -34,12 +34,12 @@ OutputVector translate_reshape(const NodeContext & context) {
     if (op_case == 1) {
         if (context.is_stateful()) {
             new_shape_node = ov::op::v0::Constant::create(
-                ov::element::i64, {3},
-                std::vector<int64_t>{-1, (int64_t) output_shape[2], (int64_t) output_shape[3]});
+                ov::element::i64, {3}, std::vector<int64_t>{-1, (int64_t) output_shape[2], (int64_t) output_shape[3]});
         } else {
             new_shape_node = ov::op::v0::Constant::create(
                 ov::element::i64, {4},
-                std::vector<int64_t>{(int64_t) output_shape[0], -1, (int64_t) output_shape[2], (int64_t) output_shape[3]});
+                std::vector<int64_t>{(int64_t) output_shape[0], -1, (int64_t) output_shape[2],
+                                     (int64_t) output_shape[3]});
         }
     } else if (op_case == 2) {
         new_shape_node = ov::op::v0::Constant::create(
@@ -47,7 +47,14 @@ OutputVector translate_reshape(const NodeContext & context) {
             std::vector<int64_t>{(int64_t) output_shape[0], (int64_t) output_shape[1], -1, (int64_t) output_shape[3]});
 
     } else if (op_case == 3) {
-        throw std::runtime_error("might be outdated RESHAPE case");
+        //  -  14: [     1,  1024,     1,     1] RESHAPE              Vcur-0 (reshaped) (reshaped)
+        //         [   512,     2,     1,     1]            0: RESHAPE     Vcur-0 (reshaped)
+        //  -  15: [     1, 524288,     1,     1] RESHAPE              cache_v_l0 (reshaped)
+        //         [   512,  1024,     1,     1]            0: NONE        cache_v_l0
+        //  -  16: [     1, 524288,     1,     1] SET_ROWS             cache_v_l0 (reshaped) (view)
+        //         [     1,  1024,     1,     1]            0: RESHAPE     Vcur-0 (reshaped) (reshaped)
+        //         [  1024,     1,     1,     1]            1: NONE        leaf_11
+        //         [     1, 524288,     1,     1]            2: RESHAPE     cache_v_l0 (reshaped)
         new_shape_node = ov::op::v0::Constant::create(
             ov::element::i64, {4}, std::vector<int64_t>{(int64_t) output_shape[0], (int64_t) output_shape[1], -1, 1});
 

data/ext/sources/ggml/src/ggml-openvino/openvino/op/rms_norm.cpp

@@ -19,7 +19,7 @@ namespace op {
 OutputVector translate_rms_norm(const NodeContext & context) {
     num_inputs_check(context, 1, 1);
 
-    auto input_node = context.get_input(0);
+    auto input_node = process_view_input_new(context, 0);
     auto square = std::make_shared<ov::op::v1::Power>(
         input_node, ov::op::v0::Constant::create(ov::element::f32, ov::Shape{1}, {2.0f}));