whisper.rn 0.4.0-rc.9 → 0.4.0

package/cpp/gguf.h

@@ -0,0 +1,202 @@
+// This file contains functionality related to "GGUF" files, the binary file format used by ggml.
+// GGUF files have the following structure:
+//
+// 1. File magic "GGUF" (4 bytes).
+// 2. File version (uint32_t).
+// 3. Number of ggml tensors in file (int64_t).
+// 4. Number of key-value-pairs in file (int64_t).
+// 5. For each KV pair:
+//   1. The key (string).
+//   2. The value type (wsp_gguf_type).
+//   3a. If the value type is WSP_GGUF_TYPE_ARRAY:
+//     1. The type of the array (wsp_gguf_type).
+//     2. The number of elements in the array (uint64_t).
+//     3. The binary representation of each element in the array.
+//   3b. Otherwise:
+//     1. The binary representation of the value.
+// 6. For each ggml tensor:
+//   1. The tensor name (string).
+//   2. The number of dimensions of the tensor (uint32_t).
+//   3. For each dimension:
+//     1. The size of the tensor in the dimension (int64_t).
+//   4. The tensor data type (wsp_ggml_type).
+//   5. The tensor data offset in the tensor data binary blob (uint64_t).
+// 7. The tensor data binary blob (optional, aligned).
+//
+// Strings are serialized as the string length (uint64_t) followed by the C string without the null terminator.
+// All enums are stored as int32_t.
+// All bool values are stored as int8_t.
+// If the special key "general.alignment" (uint32_t) is defined it is used for alignment,
+//   otherwise WSP_GGUF_DEFAULT_ALIGNMENT is used.
+//
+// Module maintainer: Johannes Gäßler (@JohannesGaessler, johannesg@5d6.de)
+
+#pragma once
+
+#include "ggml.h"
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#define WSP_GGUF_MAGIC   "GGUF"
+#define WSP_GGUF_VERSION 3
+
+#define WSP_GGUF_KEY_GENERAL_ALIGNMENT "general.alignment"
+
+#define WSP_GGUF_DEFAULT_ALIGNMENT 32
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+    // types that can be stored as GGUF KV data
+    enum wsp_gguf_type {
+        WSP_GGUF_TYPE_UINT8   = 0,
+        WSP_GGUF_TYPE_INT8    = 1,
+        WSP_GGUF_TYPE_UINT16  = 2,
+        WSP_GGUF_TYPE_INT16   = 3,
+        WSP_GGUF_TYPE_UINT32  = 4,
+        WSP_GGUF_TYPE_INT32   = 5,
+        WSP_GGUF_TYPE_FLOAT32 = 6,
+        WSP_GGUF_TYPE_BOOL    = 7,
+        WSP_GGUF_TYPE_STRING  = 8,
+        WSP_GGUF_TYPE_ARRAY   = 9,
+        WSP_GGUF_TYPE_UINT64  = 10,
+        WSP_GGUF_TYPE_INT64   = 11,
+        WSP_GGUF_TYPE_FLOAT64 = 12,
+        WSP_GGUF_TYPE_COUNT,       // marks the end of the enum
+    };
+
+    struct wsp_gguf_context;
+
+    struct wsp_gguf_init_params {
+        bool no_alloc;
+
+        // if not NULL, create a wsp_ggml_context and allocate the tensor data in it
+        struct wsp_ggml_context ** ctx;
+    };
+
+    WSP_GGML_API struct wsp_gguf_context * wsp_gguf_init_empty(void);
+    WSP_GGML_API struct wsp_gguf_context * wsp_gguf_init_from_file(const char * fname, struct wsp_gguf_init_params params);
+    //WSP_GGML_API struct wsp_gguf_context * wsp_gguf_init_from_buffer(..);
+
+    WSP_GGML_API void wsp_gguf_free(struct wsp_gguf_context * ctx);
+
+    WSP_GGML_API const char * wsp_gguf_type_name(enum wsp_gguf_type type);
+
+    WSP_GGML_API uint32_t wsp_gguf_get_version    (const struct wsp_gguf_context * ctx);
+    WSP_GGML_API size_t   wsp_gguf_get_alignment  (const struct wsp_gguf_context * ctx);
+    WSP_GGML_API size_t   wsp_gguf_get_data_offset(const struct wsp_gguf_context * ctx);
+
+    WSP_GGML_API int64_t      wsp_gguf_get_n_kv(const struct wsp_gguf_context * ctx);
+    WSP_GGML_API int64_t      wsp_gguf_find_key(const struct wsp_gguf_context * ctx, const char * key); // returns -1 if key is not found
+    WSP_GGML_API const char * wsp_gguf_get_key (const struct wsp_gguf_context * ctx, int64_t key_id);
+
+    WSP_GGML_API enum wsp_gguf_type wsp_gguf_get_kv_type (const struct wsp_gguf_context * ctx, int64_t key_id);
+    WSP_GGML_API enum wsp_gguf_type wsp_gguf_get_arr_type(const struct wsp_gguf_context * ctx, int64_t key_id);
+
+    // will abort if the wrong type is used for the key
+    WSP_GGML_API uint8_t      wsp_gguf_get_val_u8  (const struct wsp_gguf_context * ctx, int64_t key_id);
+    WSP_GGML_API int8_t       wsp_gguf_get_val_i8  (const struct wsp_gguf_context * ctx, int64_t key_id);
+    WSP_GGML_API uint16_t     wsp_gguf_get_val_u16 (const struct wsp_gguf_context * ctx, int64_t key_id);
+    WSP_GGML_API int16_t      wsp_gguf_get_val_i16 (const struct wsp_gguf_context * ctx, int64_t key_id);
+    WSP_GGML_API uint32_t     wsp_gguf_get_val_u32 (const struct wsp_gguf_context * ctx, int64_t key_id);
+    WSP_GGML_API int32_t      wsp_gguf_get_val_i32 (const struct wsp_gguf_context * ctx, int64_t key_id);
+    WSP_GGML_API float        wsp_gguf_get_val_f32 (const struct wsp_gguf_context * ctx, int64_t key_id);
+    WSP_GGML_API uint64_t     wsp_gguf_get_val_u64 (const struct wsp_gguf_context * ctx, int64_t key_id);
+    WSP_GGML_API int64_t      wsp_gguf_get_val_i64 (const struct wsp_gguf_context * ctx, int64_t key_id);
+    WSP_GGML_API double       wsp_gguf_get_val_f64 (const struct wsp_gguf_context * ctx, int64_t key_id);
+    WSP_GGML_API bool         wsp_gguf_get_val_bool(const struct wsp_gguf_context * ctx, int64_t key_id);
+    WSP_GGML_API const char * wsp_gguf_get_val_str (const struct wsp_gguf_context * ctx, int64_t key_id);
+    WSP_GGML_API const void * wsp_gguf_get_val_data(const struct wsp_gguf_context * ctx, int64_t key_id);
+    WSP_GGML_API size_t       wsp_gguf_get_arr_n   (const struct wsp_gguf_context * ctx, int64_t key_id);
+
+    // get raw pointer to the first element of the array with the given key_id
+    // for bool arrays, note that they are always stored as int8 on all platforms (usually this makes no difference)
+    WSP_GGML_API const void * wsp_gguf_get_arr_data(const struct wsp_gguf_context * ctx, int64_t key_id);
+
+    // get ith C string from array with given key_id
+    WSP_GGML_API const char * wsp_gguf_get_arr_str (const struct wsp_gguf_context * ctx, int64_t key_id, size_t i);
+
+    WSP_GGML_API int64_t        wsp_gguf_get_n_tensors    (const struct wsp_gguf_context * ctx);
+    WSP_GGML_API int64_t        wsp_gguf_find_tensor      (const struct wsp_gguf_context * ctx, const char * name); // returns -1 if the tensor is not found
+    WSP_GGML_API size_t         wsp_gguf_get_tensor_offset(const struct wsp_gguf_context * ctx, int64_t tensor_id);
+    WSP_GGML_API const char *   wsp_gguf_get_tensor_name  (const struct wsp_gguf_context * ctx, int64_t tensor_id);
+    WSP_GGML_API enum wsp_ggml_type wsp_gguf_get_tensor_type  (const struct wsp_gguf_context * ctx, int64_t tensor_id);
+    WSP_GGML_API size_t         wsp_gguf_get_tensor_size  (const struct wsp_gguf_context * ctx, int64_t tensor_id);
+
+    // removes key if it exists, returns id that the key had prior to removal (-1 if it didn't exist)
+    WSP_GGML_API int64_t wsp_gguf_remove_key(struct wsp_gguf_context * ctx, const char * key);
+
+    // overrides an existing KV pair or adds a new one, the new KV pair is always at the back
+    WSP_GGML_API void wsp_gguf_set_val_u8  (struct wsp_gguf_context * ctx, const char * key, uint8_t      val);
+    WSP_GGML_API void wsp_gguf_set_val_i8  (struct wsp_gguf_context * ctx, const char * key, int8_t       val);
+    WSP_GGML_API void wsp_gguf_set_val_u16 (struct wsp_gguf_context * ctx, const char * key, uint16_t     val);
+    WSP_GGML_API void wsp_gguf_set_val_i16 (struct wsp_gguf_context * ctx, const char * key, int16_t      val);
+    WSP_GGML_API void wsp_gguf_set_val_u32 (struct wsp_gguf_context * ctx, const char * key, uint32_t     val);
+    WSP_GGML_API void wsp_gguf_set_val_i32 (struct wsp_gguf_context * ctx, const char * key, int32_t      val);
+    WSP_GGML_API void wsp_gguf_set_val_f32 (struct wsp_gguf_context * ctx, const char * key, float        val);
+    WSP_GGML_API void wsp_gguf_set_val_u64 (struct wsp_gguf_context * ctx, const char * key, uint64_t     val);
+    WSP_GGML_API void wsp_gguf_set_val_i64 (struct wsp_gguf_context * ctx, const char * key, int64_t      val);
+    WSP_GGML_API void wsp_gguf_set_val_f64 (struct wsp_gguf_context * ctx, const char * key, double       val);
+    WSP_GGML_API void wsp_gguf_set_val_bool(struct wsp_gguf_context * ctx, const char * key, bool         val);
+    WSP_GGML_API void wsp_gguf_set_val_str (struct wsp_gguf_context * ctx, const char * key, const char * val);
+
+    // creates a new array with n elements of the given type and copies the corresponding number of bytes from data
+    WSP_GGML_API void wsp_gguf_set_arr_data(struct wsp_gguf_context * ctx, const char * key, enum wsp_gguf_type type, const void * data, size_t n);
+
+    // creates a new array with n strings and copies the corresponding strings from data
+    WSP_GGML_API void wsp_gguf_set_arr_str (struct wsp_gguf_context * ctx, const char * key, const char ** data, size_t n);
+
+    // set or add KV pairs from another context
+    WSP_GGML_API void wsp_gguf_set_kv(struct wsp_gguf_context * ctx, const struct wsp_gguf_context * src);
+
+    // add tensor to GGUF context, tensor name must be unique
+    WSP_GGML_API void wsp_gguf_add_tensor(struct wsp_gguf_context * ctx, const struct wsp_ggml_tensor * tensor);
+
+    // after changing a tensor's type, the offsets of all tensors with higher indices are immediately recalculated
+    //   in such a way that the tensor data remains as one contiguous block (except for padding)
+    WSP_GGML_API void wsp_gguf_set_tensor_type(struct wsp_gguf_context * ctx, const char * name, enum wsp_ggml_type type);
+
+    // assumes that at least wsp_gguf_get_tensor_size bytes can be read from data
+    WSP_GGML_API void wsp_gguf_set_tensor_data(struct wsp_gguf_context * ctx, const char * name, const void * data);
+
+    // writing gguf files can be done in 3 ways:
+    //
+    // - write the entire wsp_gguf_context to a binary file in a single pass:
+    //
+    //   wsp_gguf_write_to_file(ctx, fname, /*only_meta =*/ false);
+    //
+    // - write only the meta data to a file, then re-open the file and append the tensor data:
+    //
+    //   wsp_gguf_write_to_file(ctx, fname, /*only_meta =*/ true);
+    //   FILE * f = fopen(fname, "ab");
+    //   fwrite(f, ...); // write tensor data
+    //   fclose(f);
+    //
+    // - first prepare a file with a placeholder for the meta data, write the tensor data, then write the meta data:
+    //
+    //   FILE * f = fopen(fname, "wb");
+    //   const size_t size_meta = wsp_gguf_get_meta_size(ctx);
+    //   fseek(f, size_meta, SEEK_SET);
+    //   fwrite(f, ...); // write tensor data
+    //   void * data = malloc(size_meta);
+    //   wsp_gguf_get_meta_data(ctx, data);
+    //   rewind(f);
+    //   fwrite(data, 1, data, f);
+    //   free(data);
+    //   fclose(f);
+    //
+
+    // write the entire context to a binary file
+    WSP_GGML_API bool wsp_gguf_write_to_file(const struct wsp_gguf_context * ctx, const char * fname, bool only_meta);
+
+    // get the size in bytes of the meta data (header, kv pairs, tensor info) including padding
+    WSP_GGML_API size_t wsp_gguf_get_meta_size(const struct wsp_gguf_context * ctx);
+
+    // writes the meta data to pointer "data"
+    WSP_GGML_API void   wsp_gguf_get_meta_data(const struct wsp_gguf_context * ctx, void * data);
+
+#ifdef  __cplusplus
+}
+#endif

package/cpp/rn-whisper.cpp

@@ -17,10 +17,8 @@ const char * system_info(void) {
   if (wsp_ggml_cpu_has_fma() == 1) s += "FMA ";
   if (wsp_ggml_cpu_has_neon() == 1) s += "NEON ";
   if (wsp_ggml_cpu_has_arm_fma() == 1) s += "ARM_FMA ";
-  if (wsp_ggml_cpu_has_metal() == 1) s += "METAL ";
   if (wsp_ggml_cpu_has_f16c() == 1) s += "F16C ";
   if (wsp_ggml_cpu_has_fp16_va() == 1) s += "FP16_VA ";
-  if (wsp_ggml_cpu_has_blas() == 1) s += "BLAS ";
   if (wsp_ggml_cpu_has_sse3() == 1) s += "SSE3 ";
   if (wsp_ggml_cpu_has_ssse3() == 1) s += "SSSE3 ";
   if (wsp_ggml_cpu_has_vsx() == 1) s += "VSX ";
@@ -85,18 +83,13 @@ std::string bench(struct whisper_context * ctx, int n_threads) {
 
     const struct whisper_timings * timings = whisper_get_timings(ctx);
 
-    const int32_t n_encode = std::max(1, timings->n_encode);
-    const int32_t n_decode = std::max(1, timings->n_decode);
-    const int32_t n_batchd = std::max(1, timings->n_batchd);
-    const int32_t n_prompt = std::max(1, timings->n_prompt);
-
     return std::string("[") +
         "\"" + system_info() + "\"," +
         std::to_string(n_threads) + "," +
-        std::to_string(1e-3f * timings->t_encode_us / n_encode) + "," +
-        std::to_string(1e-3f * timings->t_decode_us / n_decode) + "," +
-        std::to_string(1e-3f * timings->t_batchd_us / n_batchd) + "," +
-        std::to_string(1e-3f * timings->t_prompt_us / n_prompt) + "]";
+        std::to_string(timings->encode_ms) + "," +
+        std::to_string(timings->decode_ms) + "," +
+        std::to_string(timings->batchd_ms) + "," +
+        std::to_string(timings->prompt_ms) + "]";
 }
 
 void high_pass_filter(std::vector<float> & data, float cutoff, float sample_rate) {

package/cpp/whisper-arch.h

@@ -0,0 +1,197 @@
+#pragma once
+
+#include "ggml.h"
+
+#include <map>
+
+enum asr_tensor {
+    ASR_TENSOR_ENC_POS_EMBD,
+    ASR_TENSOR_DEC_POS_EMBD,
+    ASR_TENSOR_DEC_TOKEN_EMBD_WEIGHT,
+    ASR_TENSOR_LN_WEIGHT,
+    ASR_TENSOR_LN_BIAS,
+    ASR_TENSOR_CONV1_WEIGHT,
+    ASR_TENSOR_CONV1_BIAS,
+    ASR_TENSOR_CONV2_WEIGHT,
+    ASR_TENSOR_CONV2_BIAS,
+    ASR_TENSOR_LN_POST_WEIGHT,
+    ASR_TENSOR_LN_POST_BIAS,
+    ASR_TENSOR_MLP_LN_WEIGHT,
+    ASR_TENSOR_MLP_LN_BIAS,
+    ASR_TENSOR_MLP_0_WEIGHT,
+    ASR_TENSOR_MLP_0_BIAS,
+    ASR_TENSOR_MLP_2_WEIGHT,
+    ASR_TENSOR_MLP_2_BIAS,
+    ASR_TENSOR_ATTN_LN_WEIGHT,
+    ASR_TENSOR_ATTN_LN_BIAS,
+    ASR_TENSOR_ATTN_QUERY_WEIGHT,
+    ASR_TENSOR_ATTN_QUERY_BIAS,
+    ASR_TENSOR_ATTN_KEY_WEIGHT,
+    ASR_TENSOR_ATTN_VALUE_WEIGHT,
+    ASR_TENSOR_ATTN_VALUE_BIAS,
+    ASR_TENSOR_ATTN_OUT_WEIGHT,
+    ASR_TENSOR_ATTN_OUT_BIAS,
+};
+
+enum asr_system {
+    ASR_SYSTEM_ENCODER,
+    ASR_SYSTEM_DECODER,
+    ASR_SYSTEM_CROSS
+};
+
+static const std::map<asr_system, std::map<asr_tensor, const char *>> ASR_TENSOR_NAMES = {
+    {
+        ASR_SYSTEM_ENCODER,
+        {
+            {ASR_TENSOR_ENC_POS_EMBD, "encoder.positional_embedding"},
+            {ASR_TENSOR_CONV1_WEIGHT, "encoder.conv1.weight"},
+            {ASR_TENSOR_CONV1_BIAS, "encoder.conv1.bias"},
+            {ASR_TENSOR_CONV2_WEIGHT, "encoder.conv2.weight"},
+            {ASR_TENSOR_CONV2_BIAS, "encoder.conv2.bias"},
+            {ASR_TENSOR_LN_WEIGHT, "encoder.ln_post.weight"},
+            {ASR_TENSOR_LN_POST_BIAS, "encoder.ln_post.bias"},
+            {ASR_TENSOR_MLP_LN_WEIGHT, "encoder.blocks.%d.mlp_ln.weight"},
+            {ASR_TENSOR_MLP_LN_BIAS, "encoder.blocks.%d.mlp_ln.bias"},
+            {ASR_TENSOR_MLP_0_WEIGHT, "encoder.blocks.%d.mlp.0.weight"},
+            {ASR_TENSOR_MLP_0_BIAS, "encoder.blocks.%d.mlp.0.bias"},
+            {ASR_TENSOR_MLP_2_WEIGHT, "encoder.blocks.%d.mlp.2.weight"},
+            {ASR_TENSOR_MLP_2_BIAS, "encoder.blocks.%d.mlp.2.bias"},
+            {ASR_TENSOR_ATTN_LN_WEIGHT, "encoder.blocks.%d.attn_ln.weight"},
+            {ASR_TENSOR_ATTN_LN_BIAS, "encoder.blocks.%d.attn_ln.bias"},
+            {ASR_TENSOR_ATTN_QUERY_WEIGHT, "encoder.blocks.%d.attn.query.weight"},
+            {ASR_TENSOR_ATTN_QUERY_BIAS, "encoder.blocks.%d.attn.query.bias"},
+            {ASR_TENSOR_ATTN_KEY_WEIGHT, "encoder.blocks.%d.attn.key.weight"},
+            {ASR_TENSOR_ATTN_VALUE_WEIGHT, "encoder.blocks.%d.attn.value.weight"},
+            {ASR_TENSOR_ATTN_VALUE_BIAS, "encoder.blocks.%d.attn.value.bias"},
+            {ASR_TENSOR_ATTN_OUT_WEIGHT, "encoder.blocks.%d.attn.out.weight"},
+            {ASR_TENSOR_ATTN_OUT_BIAS, "encoder.blocks.%d.attn.out.bias"},
+        },
+    },
+    {
+        ASR_SYSTEM_DECODER,
+        {
+            {ASR_TENSOR_DEC_POS_EMBD, "decoder.positional_embedding"},
+            {ASR_TENSOR_DEC_TOKEN_EMBD_WEIGHT, "decoder.token_embedding.weight"},
+            {ASR_TENSOR_LN_WEIGHT, "decoder.ln.weight"},
+            {ASR_TENSOR_LN_BIAS, "decoder.ln.bias"},
+
+            {ASR_TENSOR_MLP_LN_WEIGHT, "decoder.blocks.%d.mlp_ln.weight"},
+            {ASR_TENSOR_MLP_LN_BIAS, "decoder.blocks.%d.mlp_ln.bias"},
+            {ASR_TENSOR_MLP_0_WEIGHT, "decoder.blocks.%d.mlp.0.weight"},
+            {ASR_TENSOR_MLP_0_BIAS, "decoder.blocks.%d.mlp.0.bias"},
+            {ASR_TENSOR_MLP_2_WEIGHT, "decoder.blocks.%d.mlp.2.weight"},
+            {ASR_TENSOR_MLP_2_BIAS, "decoder.blocks.%d.mlp.2.bias"},
+            {ASR_TENSOR_ATTN_LN_WEIGHT, "decoder.blocks.%d.attn_ln.weight"},
+            {ASR_TENSOR_ATTN_LN_BIAS, "decoder.blocks.%d.attn_ln.bias"},
+            {ASR_TENSOR_ATTN_QUERY_WEIGHT, "decoder.blocks.%d.attn.query.weight"},
+            {ASR_TENSOR_ATTN_QUERY_BIAS, "decoder.blocks.%d.attn.query.bias"},
+            {ASR_TENSOR_ATTN_KEY_WEIGHT, "decoder.blocks.%d.attn.key.weight"},
+            {ASR_TENSOR_ATTN_VALUE_WEIGHT, "decoder.blocks.%d.attn.value.weight"},
+            {ASR_TENSOR_ATTN_VALUE_BIAS, "decoder.blocks.%d.attn.value.bias"},
+            {ASR_TENSOR_ATTN_OUT_WEIGHT, "decoder.blocks.%d.attn.out.weight"},
+            {ASR_TENSOR_ATTN_OUT_BIAS, "decoder.blocks.%d.attn.out.bias"},
+        },
+    },
+    {
+        ASR_SYSTEM_CROSS,
+        {
+            {ASR_TENSOR_ATTN_LN_WEIGHT, "decoder.blocks.%d.cross_attn_ln.weight"},
+            {ASR_TENSOR_ATTN_LN_BIAS, "decoder.blocks.%d.cross_attn_ln.bias"},
+            {ASR_TENSOR_ATTN_QUERY_WEIGHT, "decoder.blocks.%d.cross_attn.query.weight"},
+            {ASR_TENSOR_ATTN_QUERY_BIAS, "decoder.blocks.%d.cross_attn.query.bias"},
+            {ASR_TENSOR_ATTN_KEY_WEIGHT, "decoder.blocks.%d.cross_attn.key.weight"},
+            {ASR_TENSOR_ATTN_VALUE_WEIGHT, "decoder.blocks.%d.cross_attn.value.weight"},
+            {ASR_TENSOR_ATTN_VALUE_BIAS, "decoder.blocks.%d.cross_attn.value.bias"},
+            {ASR_TENSOR_ATTN_OUT_WEIGHT, "decoder.blocks.%d.cross_attn.out.weight"},
+            {ASR_TENSOR_ATTN_OUT_BIAS, "decoder.blocks.%d.cross_attn.out.bias"},
+        },
+    },
+};
+
+static const std::map<asr_tensor, wsp_ggml_op> ASR_TENSOR_INFO = {
+    {ASR_TENSOR_ENC_POS_EMBD,          WSP_GGML_OP_ADD},
+    {ASR_TENSOR_DEC_POS_EMBD,          WSP_GGML_OP_GET_ROWS},
+    // Note: ASR_TENSOR_DEC_TOKEN_EMBD_WEIGHT is also used by WSP_GGML_OP_MAT_MUL. Need to figure out a way how to handle
+    // weight tensors that are used by multiple different operators when extra_buffer_type implementations accelerate
+    // more than just WSP_GGML_OP_MUL_MAT.
+    {ASR_TENSOR_DEC_TOKEN_EMBD_WEIGHT, WSP_GGML_OP_GET_ROWS},
+    {ASR_TENSOR_LN_WEIGHT,             WSP_GGML_OP_MUL},
+    {ASR_TENSOR_LN_BIAS,               WSP_GGML_OP_ADD},
+    {ASR_TENSOR_CONV1_WEIGHT,          WSP_GGML_OP_IM2COL},
+    {ASR_TENSOR_CONV1_BIAS,            WSP_GGML_OP_ADD},
+    {ASR_TENSOR_CONV2_WEIGHT,          WSP_GGML_OP_IM2COL},
+    {ASR_TENSOR_CONV2_BIAS,            WSP_GGML_OP_ADD},
+    {ASR_TENSOR_LN_POST_WEIGHT,        WSP_GGML_OP_MUL},
+    {ASR_TENSOR_LN_POST_BIAS,          WSP_GGML_OP_ADD},
+    {ASR_TENSOR_MLP_LN_WEIGHT,         WSP_GGML_OP_MUL},
+    {ASR_TENSOR_MLP_LN_BIAS,           WSP_GGML_OP_ADD},
+    {ASR_TENSOR_MLP_0_WEIGHT,          WSP_GGML_OP_MUL_MAT},
+    {ASR_TENSOR_MLP_0_BIAS,            WSP_GGML_OP_ADD},
+    {ASR_TENSOR_MLP_2_WEIGHT,          WSP_GGML_OP_MUL_MAT},
+    {ASR_TENSOR_MLP_2_BIAS,            WSP_GGML_OP_ADD},
+    {ASR_TENSOR_ATTN_LN_WEIGHT,        WSP_GGML_OP_MUL},
+    {ASR_TENSOR_ATTN_LN_BIAS,          WSP_GGML_OP_ADD},
+    {ASR_TENSOR_ATTN_QUERY_WEIGHT,     WSP_GGML_OP_MUL_MAT},
+    {ASR_TENSOR_ATTN_QUERY_BIAS,       WSP_GGML_OP_ADD},
+    {ASR_TENSOR_ATTN_KEY_WEIGHT,       WSP_GGML_OP_MUL_MAT},
+    {ASR_TENSOR_ATTN_VALUE_WEIGHT,     WSP_GGML_OP_MUL_MAT},
+    {ASR_TENSOR_ATTN_VALUE_BIAS,       WSP_GGML_OP_ADD},
+    {ASR_TENSOR_ATTN_OUT_WEIGHT,       WSP_GGML_OP_MUL_MAT},
+    {ASR_TENSOR_ATTN_OUT_BIAS,         WSP_GGML_OP_ADD},
+};
+
+enum vad_tensor {
+    VAD_TENSOR_STFT_BASIS,
+    VAD_TENSOR_ENC_0_WEIGHT,
+    VAD_TENSOR_ENC_0_BIAS,
+    VAD_TENSOR_ENC_1_WEIGHT,
+    VAD_TENSOR_ENC_1_BIAS,
+    VAD_TENSOR_ENC_2_WEIGHT,
+    VAD_TENSOR_ENC_2_BIAS,
+    VAD_TENSOR_ENC_3_WEIGHT,
+    VAD_TENSOR_ENC_3_BIAS,
+    VAD_TENSOR_LSTM_WEIGHT_IH,
+    VAD_TENSOR_LSTM_WEIGHT_HH,
+    VAD_TENSOR_LSTM_BIAS_IH,
+    VAD_TENSOR_LSTM_BIAS_HH,
+    VAD_TENSOR_FINAL_CONV_WEIGHT,
+    VAD_TENSOR_FINAL_CONV_BIAS,
+};
+
+static const std::map<vad_tensor, wsp_ggml_op> VAD_TENSOR_OPS = {
+    {VAD_TENSOR_STFT_BASIS,          WSP_GGML_OP_IM2COL},
+    {VAD_TENSOR_ENC_0_WEIGHT,        WSP_GGML_OP_IM2COL},
+    {VAD_TENSOR_ENC_0_BIAS,          WSP_GGML_OP_ADD},
+    {VAD_TENSOR_ENC_1_WEIGHT,        WSP_GGML_OP_IM2COL},
+    {VAD_TENSOR_ENC_1_BIAS,          WSP_GGML_OP_ADD},
+    {VAD_TENSOR_ENC_2_WEIGHT,        WSP_GGML_OP_IM2COL},
+    {VAD_TENSOR_ENC_2_BIAS,          WSP_GGML_OP_ADD},
+    {VAD_TENSOR_ENC_3_WEIGHT,        WSP_GGML_OP_IM2COL},
+    {VAD_TENSOR_ENC_3_BIAS,          WSP_GGML_OP_ADD},
+
+    {VAD_TENSOR_LSTM_WEIGHT_IH,      WSP_GGML_OP_MUL_MAT},
+    {VAD_TENSOR_LSTM_WEIGHT_HH,      WSP_GGML_OP_MUL_MAT},
+    {VAD_TENSOR_LSTM_BIAS_IH,        WSP_GGML_OP_ADD},
+    {VAD_TENSOR_LSTM_BIAS_HH,        WSP_GGML_OP_ADD},
+
+    {VAD_TENSOR_FINAL_CONV_WEIGHT,   WSP_GGML_OP_IM2COL},
+    {VAD_TENSOR_FINAL_CONV_BIAS,     WSP_GGML_OP_ADD}
+};
+
+static const std::map<vad_tensor, const char *> VAD_TENSOR_NAMES = {
+    {VAD_TENSOR_STFT_BASIS,          "_model.stft.forward_basis_buffer"},
+    {VAD_TENSOR_ENC_0_WEIGHT,        "_model.encoder.0.reparam_conv.weight"},
+    {VAD_TENSOR_ENC_0_BIAS,          "_model.encoder.0.reparam_conv.bias"},
+    {VAD_TENSOR_ENC_1_WEIGHT,        "_model.encoder.1.reparam_conv.weight"},
+    {VAD_TENSOR_ENC_1_BIAS,          "_model.encoder.1.reparam_conv.bias"},
+    {VAD_TENSOR_ENC_2_WEIGHT,        "_model.encoder.2.reparam_conv.weight"},
+    {VAD_TENSOR_ENC_2_BIAS,          "_model.encoder.2.reparam_conv.bias"},
+    {VAD_TENSOR_ENC_3_WEIGHT,        "_model.encoder.3.reparam_conv.weight"},
+    {VAD_TENSOR_ENC_3_BIAS,          "_model.encoder.3.reparam_conv.bias"},
+    {VAD_TENSOR_LSTM_WEIGHT_IH,      "_model.decoder.rnn.weight_ih"},
+    {VAD_TENSOR_LSTM_WEIGHT_HH,      "_model.decoder.rnn.weight_hh"},
+    {VAD_TENSOR_LSTM_BIAS_IH,        "_model.decoder.rnn.bias_ih"},
+    {VAD_TENSOR_LSTM_BIAS_HH,        "_model.decoder.rnn.bias_hh"},
+    {VAD_TENSOR_FINAL_CONV_WEIGHT,   "_model.decoder.decoder.2.weight"},
+    {VAD_TENSOR_FINAL_CONV_BIAS,     "_model.decoder.decoder.2.bias"}
+};