Optimize computation with Eigen. (#2928)

csukuangfj · web-flow · commit c08541ce36e9 · 2025-12-24T11:23:45.000+08:00
This pull request introduces the Eigen library to optimize various numerical computations within the project. It systematically replaces existing manual, loop-based implementations for operations such as calculating mean and inverse standard deviation, applying feature normalization, scaling, windowing, and log-mel transformations. The primary goal of this refactoring is to enhance the overall computational performance and improve the readability and maintainability of the codebase by utilizing Eigen's highly optimized matrix and array functionalities.
diff --git a/sherpa-onnx/csrc/math-test.cc b/sherpa-onnx/csrc/math-test.cc
@@ -65,4 +65,76 @@ TEST(Scale, Case2InPlace) {
   EXPECT_EQ(src, expected);
 }
 
+/*
+
+import numpy as np
+
+def compute_mean_and_inv_std(p: np.ndarray):
+    mean = p.mean(axis=0)
+    var = np.maximum((p**2).mean(axis=0) - mean**2, 0.0)
+    std = np.sqrt(var)
+    inv_std = 1.0 / (std + 1e-5)
+    return mean.astype(np.float32), inv_std.astype(np.float32)
+
+def dump_cpp_vector(name: str, arr: np.ndarray):
+    flat = arr.flatten()
+    print(f"std::vector<float> {name} = {{")
+    line = ""
+    for i, v in enumerate(flat):
+        line += f"{v:.8f}f, "
+        if (i + 1) % 8 == 0:
+            print("  " + line)
+            line = ""
+    if line:
+        print("  " + line)
+    print("};\n")
+
+np.random.seed(42)
+num_rows, num_cols = 4, 6
+x = np.random.randn(num_rows, num_cols).astype(np.float32)
+
+mean, inv_std = compute_mean_and_inv_std(x)
+
+dump_cpp_vector("x", x)
+dump_cpp_vector("mean", mean)
+dump_cpp_vector("inv_std", inv_std)
+
+ */
+
+TEST(ComputeMeanAndInvStd, Case1) {
+  std::vector<float> x = {
+      0.49671414f,  -0.13826430f, 0.64768857f, 1.52302980f,  -0.23415338f,
+      -0.23413695f, 1.57921278f,  0.76743472f, -0.46947438f, 0.54256004f,
+      -0.46341768f, -0.46572974f, 0.24196227f, -1.91328025f, -1.72491789f,
+      -0.56228751f, -1.01283109f, 0.31424734f, -0.90802407f, -1.41230369f,
+      1.46564877f,  -0.22577630f, 0.06752820f, -1.42474818f,
+  };
+
+  std::vector<float> expected_mean = {
+      0.35246629f, -0.67410338f, -0.02026373f,
+      0.31938151f, -0.41071847f, -0.45259190f,
+  };
+
+  std::vector<float> expected_inv_std = {
+      1.13103926f, 0.94854516f, 0.83320111f,
+      1.24679470f, 2.52932906f, 1.59057319f,
+  };
+
+  std::vector<float> mean;
+  std::vector<float> inv_std;
+
+  int32_t num_rows = 4;
+  int32_t num_cols = 6;
+
+  ComputeMeanAndInvStd(x.data(), num_rows, num_cols, &mean, &inv_std);
+
+  ASSERT_EQ(mean.size(), num_cols);
+  ASSERT_EQ(inv_std.size(), num_cols);
+
+  for (int32_t i = 0; i < num_cols; ++i) {
+    EXPECT_NEAR(mean[i], expected_mean[i], 1e-6f) << "at index " << i;
+    EXPECT_NEAR(inv_std[i], expected_inv_std[i], 1e-6f) << "at index " << i;
+  }
+}
+
 }  // namespace sherpa_onnx
diff --git a/sherpa-onnx/csrc/math.cc b/sherpa-onnx/csrc/math.cc
@@ -4,6 +4,9 @@
 #include "sherpa-onnx/csrc/math.h"
 
 #include <vector>
+
+#include "Eigen/Dense"
+
 namespace sherpa_onnx {
 
 void ScaleAdd(const float *src, float scale, int32_t n, float *in_out) {
@@ -72,4 +75,27 @@ std::vector<float> Transpose(const float *input, int32_t rows, int32_t cols) {
   return output;
 }
 
+void ComputeMeanAndInvStd(const float *p, int32_t num_rows, int32_t num_cols,
+                          std::vector<float> *mean,
+                          std::vector<float> *inv_stddev) {
+  using RowMajorMat =
+      Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>;
+
+  Eigen::Map<const RowMajorMat> X(p, num_rows, num_cols);
+
+  Eigen::RowVectorXf mean_vec = X.colwise().mean();
+
+  Eigen::RowVectorXf mean_sq = X.array().square().colwise().mean();
+
+  Eigen::RowVectorXf var = mean_sq.array() - mean_vec.array().square();
+
+  Eigen::RowVectorXf stddev = var.array().max(0.0f).sqrt();
+
+  Eigen::RowVectorXf inv_std = (stddev.array() + 1e-5f).inverse();
+
+  mean->assign(mean_vec.data(), mean_vec.data() + num_cols);
+
+  inv_stddev->assign(inv_std.data(), inv_std.data() + num_cols);
+}
+
 }  // namespace sherpa_onnx
diff --git a/sherpa-onnx/csrc/math.h b/sherpa-onnx/csrc/math.h
@@ -147,5 +147,19 @@ std::vector<float> ComputeAcousticEmbedding(
 // Transpose a 2-D matrix in row-major
 std::vector<float> Transpose(const float *input, int32_t rows, int32_t cols);
 
+/* Compute mean and inverse stddev over rows.
+ *
+ * @param p  A pointer to a 2-d array of shape (num_rows, num_cols)
+ * @param num_rows Number of rows
+ * @param num_cols Number of columns
+ * @param mean On return, it contains p.mean(axis=0). You don't need to
+ *             pre-allocate space for it.
+ * @param inv_stddev On return, it contains 1/p.std(axis=0) You don't need to
+ *                   pre-allocate space for it.
+ */
+void ComputeMeanAndInvStd(const float *p, int32_t num_rows, int32_t num_cols,
+                          std::vector<float> *mean,
+                          std::vector<float> *inv_stddev);
+
 }  // namespace sherpa_onnx
 #endif  // SHERPA_ONNX_CSRC_MATH_H_
diff --git a/sherpa-onnx/csrc/offline-dolphin-model.cc b/sherpa-onnx/csrc/offline-dolphin-model.cc
@@ -19,6 +19,7 @@
 #include "rawfile/raw_file_manager.h"
 #endif
 
+#include "Eigen/Dense"
 #include "sherpa-onnx/csrc/file-utils.h"
 #include "sherpa-onnx/csrc/macros.h"
 #include "sherpa-onnx/csrc/onnx-utils.h"
@@ -65,16 +66,15 @@ class OfflineDolphinModel::Impl {
 
   void NormalizeFeatures(float *features, int32_t num_frames,
                          int32_t feat_dim) const {
-    auto p = features;
-    const auto &mean = meta_data_.mean;
-    const auto &invstd = meta_data_.inv_stddev;
-
-    for (int32_t f = 0; f < num_frames; ++f) {
-      for (int32_t d = 0; d < feat_dim; ++d) {
-        p[d] = (p[d] - mean[d]) * invstd[d];
-      }
-      p += feat_dim;
-    }
+    using RowMajorMat =
+        Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>;
+    Eigen::Map<RowMajorMat> x(features, num_frames, feat_dim);
+
+    Eigen::Map<const Eigen::RowVectorXf> mean(meta_data_.mean.data(), feat_dim);
+    Eigen::Map<const Eigen::RowVectorXf> inv_std(meta_data_.inv_stddev.data(),
+                                                 feat_dim);
+    x.array() =
+        (x.array().rowwise() - mean.array()).rowwise() * inv_std.array();
   }
 
   OrtAllocator *Allocator() { return allocator_; }
diff --git a/sherpa-onnx/csrc/offline-omnilingual-asr-ctc-model.cc b/sherpa-onnx/csrc/offline-omnilingual-asr-ctc-model.cc
@@ -20,6 +20,7 @@
 #include "rawfile/raw_file_manager.h"
 #endif
 
+#include "Eigen/Dense"
 #include "sherpa-onnx/csrc/file-utils.h"
 #include "sherpa-onnx/csrc/macros.h"
 #include "sherpa-onnx/csrc/onnx-utils.h"
@@ -85,19 +86,14 @@ class OfflineOmnilingualAsrCtcModel::Impl {
       return;
     }
 
-    double s = 0;
-    double sq = 0;
-    for (int32_t i = 0; i < feat_dim; ++i) {
-      s += features[i];
-      sq += features[i] * features[i];
-    }
-
-    double mean = s / feat_dim;
-    double inv_stddev = 1 / std::sqrt(sq / feat_dim - mean * mean + 1e-5);
+    // Map the single-row feature vector
+    Eigen::Map<Eigen::ArrayXf> x(features, feat_dim);
+    float mean = x.mean();
+    float var = (x.square().mean() - mean * mean);
+    var = std::max(var, 0.0f);
+    float inv_stddev = 1.0f / std::sqrt(var + 1e-5f);
 
-    for (int32_t i = 0; i < feat_dim; ++i) {
-      features[i] = (features[i] - mean) * inv_stddev;
-    }
+    x = (x - mean) * inv_stddev;
   }
 
  private:
diff --git a/sherpa-onnx/csrc/offline-recognizer-fire-red-asr-impl.h b/sherpa-onnx/csrc/offline-recognizer-fire-red-asr-impl.h
@@ -12,6 +12,7 @@
 #include <utility>
 #include <vector>
 
+#include "Eigen/Dense"
 #include "sherpa-onnx/csrc/offline-fire-red-asr-decoder.h"
 #include "sherpa-onnx/csrc/offline-fire-red-asr-greedy-search-decoder.h"
 #include "sherpa-onnx/csrc/offline-fire-red-asr-model.h"
@@ -131,20 +132,19 @@ class OfflineRecognizerFireRedAsrImpl : public OfflineRecognizerImpl {
 
   void ApplyCMVN(std::vector<float> *v) const {
     const auto &meta_data = model_->GetModelMetadata();
-    const auto &mean = meta_data.mean;
-    const auto &inv_stddev = meta_data.inv_stddev;
-    int32_t feat_dim = static_cast<int32_t>(mean.size());
+    const auto &mean_vec = meta_data.mean;
+    const auto &inv_stddev_vec = meta_data.inv_stddev;
+    int32_t feat_dim = static_cast<int32_t>(mean_vec.size());
     int32_t num_frames = static_cast<int32_t>(v->size()) / feat_dim;
-
-    float *p = v->data();
-
-    for (int32_t i = 0; i != num_frames; ++i) {
-      for (int32_t k = 0; k != feat_dim; ++k) {
-        p[k] = (p[k] - mean[k]) * inv_stddev[k];
-      }
-
-      p += feat_dim;
-    }
+    Eigen::Map<
+        Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>>
+        mat(v->data(), num_frames, feat_dim);
+    Eigen::Map<const Eigen::RowVectorXf> mean(mean_vec.data(), feat_dim);
+    Eigen::Map<const Eigen::RowVectorXf> inv_std(inv_stddev_vec.data(),
+                                                 feat_dim);
+
+    mat.array() =
+        (mat.array().rowwise() - mean.array()).rowwise() * inv_std.array();
   }
 
  private:
diff --git a/sherpa-onnx/csrc/offline-recognizer-paraformer-impl.h b/sherpa-onnx/csrc/offline-recognizer-paraformer-impl.h
@@ -11,6 +11,7 @@
 #include <utility>
 #include <vector>
 
+#include "Eigen/Dense"
 #include "sherpa-onnx/csrc/offline-model-config.h"
 #include "sherpa-onnx/csrc/offline-paraformer-decoder.h"
 #include "sherpa-onnx/csrc/offline-paraformer-greedy-search-decoder.h"
@@ -242,19 +243,18 @@ class OfflineRecognizerParaformerImpl : public OfflineRecognizerImpl {
   void ApplyCMVN(std::vector<float> *v) const {
     const std::vector<float> &neg_mean = model_->NegativeMean();
     const std::vector<float> &inv_stddev = model_->InverseStdDev();
+    int32_t dim = static_cast<int32_t>(neg_mean.size());
+    int32_t num_frames = static_cast<int32_t>(v->size()) / dim;
 
-    int32_t dim = neg_mean.size();
-    int32_t num_frames = v->size() / dim;
+    Eigen::Map<
+        Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>>
+        mat(v->data(), num_frames, dim);
 
-    float *p = v->data();
+    Eigen::Map<const Eigen::RowVectorXf> neg_mean_vec(neg_mean.data(), dim);
+    Eigen::Map<const Eigen::RowVectorXf> inv_stddev_vec(inv_stddev.data(), dim);
 
-    for (int32_t i = 0; i != num_frames; ++i) {
-      for (int32_t k = 0; k != dim; ++k) {
-        p[k] = (p[k] + neg_mean[k]) * inv_stddev[k];
-      }
-
-      p += dim;
-    }
+    mat.array() = (mat.array().rowwise() + neg_mean_vec.array()).rowwise() *
+                  inv_stddev_vec.array();
   }
 
   OfflineRecognizerConfig config_;
diff --git a/sherpa-onnx/csrc/offline-recognizer-sense-voice-impl.h b/sherpa-onnx/csrc/offline-recognizer-sense-voice-impl.h
@@ -11,6 +11,7 @@
 #include <utility>
 #include <vector>
 
+#include "Eigen/Dense"
 #include "sherpa-onnx/csrc/macros.h"
 #include "sherpa-onnx/csrc/offline-ctc-greedy-search-decoder.h"
 #include "sherpa-onnx/csrc/offline-model-config.h"
@@ -402,22 +403,18 @@ class OfflineRecognizerSenseVoiceImpl : public OfflineRecognizerImpl {
 
   void ApplyCMVN(std::vector<float> *v) const {
     const auto &meta_data = model_->GetModelMetadata();
-
     const std::vector<float> &neg_mean = meta_data.neg_mean;
     const std::vector<float> &inv_stddev = meta_data.inv_stddev;
-
-    int32_t dim = neg_mean.size();
-    int32_t num_frames = v->size() / dim;
-
-    float *p = v->data();
-
-    for (int32_t i = 0; i != num_frames; ++i) {
-      for (int32_t k = 0; k != dim; ++k) {
-        p[k] = (p[k] + neg_mean[k]) * inv_stddev[k];
-      }
-
-      p += dim;
-    }
+    int32_t dim = static_cast<int32_t>(neg_mean.size());
+    int32_t num_frames = static_cast<int32_t>(v->size()) / dim;
+    Eigen::Map<
+        Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>>
+        mat(v->data(), num_frames, dim);
+    Eigen::Map<const Eigen::RowVectorXf> neg_mean_vec(neg_mean.data(), dim);
+
+    Eigen::Map<const Eigen::RowVectorXf> inv_stddev_vec(inv_stddev.data(), dim);
+    mat.array() = (mat.array().rowwise() + neg_mean_vec.array()).rowwise() *
+                  inv_stddev_vec.array();
   }
 
   SymbolTable symbol_table_;
diff --git a/sherpa-onnx/csrc/offline-stream.cc b/sherpa-onnx/csrc/offline-stream.cc
diff --git a/sherpa-onnx/csrc/online-recognizer-paraformer-impl.h b/sherpa-onnx/csrc/online-recognizer-paraformer-impl.h
diff --git a/sherpa-onnx/csrc/ten-vad-model.cc b/sherpa-onnx/csrc/ten-vad-model.cc
