Vocabulary Log Probabilities API

flutter/sherpa_onnx/lib/src/offline_recognizer.dart

@@ -597,6 +597,7 @@ class OfflineRecognizerResult {
   OfflineRecognizerResult(
       {required this.text,
       required this.tokens,
+      required this.tokenLogProbs,
       required this.timestamps,
       required this.lang,
       required this.emotion,
@@ -606,6 +607,10 @@ class OfflineRecognizerResult {
     return OfflineRecognizerResult(
       text: json['text'] as String? ?? '',
       tokens: (json['tokens'] as List?)?.map((e) => e as String).toList() ?? [],
+      tokenLogProbs: (json['token_log_probs'] as List?)
+              ?.map((e) => (e as num).toDouble())
+              .toList() ??
+          [],
       timestamps: (json['timestamps'] as List?)
               ?.map((e) => (e as num).toDouble())
               .toList() ??
@@ -618,12 +623,13 @@ class OfflineRecognizerResult {
 
   @override
   String toString() {
-    return 'OfflineRecognizerResult(text: $text, tokens: $tokens, timestamps: $timestamps, lang: $lang, emotion: $emotion, event: $event)';
+    return 'OfflineRecognizerResult(text: $text, tokens: $tokens, tokenLogProbs: $tokenLogProbs, timestamps: $timestamps, lang: $lang, emotion: $emotion, event: $event)';
   }
 
   Map<String, dynamic> toJson() => {
         'text': text,
         'tokens': tokens,
+        'tokenLogProbs': tokenLogProbs,
         'timestamps': timestamps,
         'lang': lang,
         'emotion': emotion,
@@ -632,6 +638,7 @@ class OfflineRecognizerResult {
 
   final String text;
   final List<String> tokens;
+  final List<double> tokenLogProbs;
   final List<double> timestamps;
   final String lang;
   final String emotion;
@@ -841,6 +848,7 @@ class OfflineRecognizer {
       return OfflineRecognizerResult(
           text: '',
           tokens: [],
+          tokenLogProbs: [],
           timestamps: [],
           lang: '',
           emotion: '',
@@ -854,6 +862,7 @@ class OfflineRecognizer {
     return OfflineRecognizerResult(
         text: parsedJson['text'],
         tokens: List<String>.from(parsedJson['tokens']),
+        tokenLogProbs: List<double>.from(parsedJson['token_log_probs'] ?? []),
         timestamps: List<double>.from(parsedJson['timestamps']),
         lang: parsedJson['lang'],
         emotion: parsedJson['emotion'],

flutter/sherpa_onnx/lib/src/offline_stream.dart

@@ -33,5 +33,40 @@ class OfflineStream {
     calloc.free(p);
   }
 
+  Map<String, List<double>>? getVocabLogProbs() {
+    final getFunc = SherpaOnnxBindings.getOfflineStreamVocabLogProbs;
+    final destroyFunc = SherpaOnnxBindings.destroyVocabLogProbs;
+
+    if (getFunc == null || destroyFunc == null) {
+      return null;
+    }
+
+    final vocabPtr = getFunc(ptr);
+    if (vocabPtr == nullptr) {
+      return null;
+    }
+
+    final vocabLogProbs = vocabPtr.ref;
+    final numTokens = vocabLogProbs.numTokens;
+    final vocabSize = vocabLogProbs.vocabSize;
+
+    final Map<String, List<double>> result = {};
+
+    for (int tokenIdx = 0; tokenIdx < numTokens; tokenIdx++) {
+      final List<double> tokenProbs = [];
+
+      for (int vocabIdx = 0; vocabIdx < vocabSize; vocabIdx++) {
+        final index = tokenIdx * vocabSize + vocabIdx;
+        final logProb = vocabLogProbs.logProbs[index];
+        tokenProbs.add(logProb);
+      }
+
+      result['token_$tokenIdx'] = tokenProbs;
+    }
+
+    destroyFunc(vocabPtr);
+    return result;
+  }
+
   Pointer<SherpaOnnxOfflineStream> ptr;
 }

flutter/sherpa_onnx/lib/src/online_recognizer.dart

@@ -327,7 +327,7 @@ class OnlineRecognizerConfig {
 
 class OnlineRecognizerResult {
   OnlineRecognizerResult(
-      {required this.text, required this.tokens, required this.timestamps});
+      {required this.text, required this.tokens, required this.timestamps, this.ysProbs = const <double>[]});
 
   factory OnlineRecognizerResult.fromJson(Map<String, dynamic> json) {
     return OnlineRecognizerResult(
@@ -336,23 +336,28 @@ class OnlineRecognizerResult {
       timestamps: (json['timestamps'] as List)
           .map<double>((e) => (e as num).toDouble())
           .toList(),
+      ysProbs: (json['ys_probs'] as List?)
+          ?.map<double>((e) => (e as num).toDouble())
+          .toList() ?? const <double>[],
     );
   }
 
   @override
   String toString() {
-    return 'OnlineRecognizerResult(text: $text, tokens: $tokens, timestamps: $timestamps)';
+    return 'OnlineRecognizerResult(text: $text, tokens: $tokens, timestamps: $timestamps, ysProbs: $ysProbs)';
   }
 
   Map<String, dynamic> toJson() => {
         'text': text,
         'tokens': tokens,
         'timestamps': timestamps,
+        'ys_probs': ysProbs,
       };
 
   final String text;
   final List<String> tokens;
   final List<double> timestamps;
+  final List<double> ysProbs;
 }
 
 class OnlineRecognizer {
@@ -499,7 +504,10 @@ class OnlineRecognizer {
     return OnlineRecognizerResult(
         text: parsedJson['text'],
         tokens: List<String>.from(parsedJson['tokens']),
-        timestamps: List<double>.from(parsedJson['timestamps']));
+        timestamps: List<double>.from(parsedJson['timestamps']),
+        ysProbs: (parsedJson['ys_probs'] as List<dynamic>?)
+    	    ?.map<double>((e) => (e as num).toDouble())
+    	    .toList() ?? <double>[]);
   }
 
   void reset(OnlineStream stream) {

flutter/sherpa_onnx/lib/src/online_stream.dart

@@ -37,5 +37,40 @@ class OnlineStream {
     SherpaOnnxBindings.onlineStreamInputFinished?.call(ptr);
   }
 
+  Map<String, List<double>>? getVocabLogProbs() {
+    final getFunc = SherpaOnnxBindings.getOnlineStreamVocabLogProbs;
+    final destroyFunc = SherpaOnnxBindings.destroyVocabLogProbs;
+
+    if (getFunc == null || destroyFunc == null) {
+      return null;
+    }
+
+    final vocabPtr = getFunc(this.ptr);
+    if (vocabPtr == nullptr) {
+      return null;
+    }
+
+    final vocabLogProbs = vocabPtr.ref;
+    final numTokens = vocabLogProbs.numTokens;
+    final vocabSize = vocabLogProbs.vocabSize;
+
+    final Map<String, List<double>> result = {};
+
+    for (int tokenIdx = 0; tokenIdx < numTokens; tokenIdx++) {
+      final List<double> tokenProbs = [];
+
+      for (int vocabIdx = 0; vocabIdx < vocabSize; vocabIdx++) {
+        final index = tokenIdx * vocabSize + vocabIdx;
+        final logProb = vocabLogProbs.logProbs[index];
+        tokenProbs.add(logProb);
+      }
+
+      result['token_$tokenIdx'] = tokenProbs;
+    }
+
+    destroyFunc(vocabPtr);
+    return result;
+  }
+
   Pointer<SherpaOnnxOnlineStream> ptr;
 }

flutter/sherpa_onnx/lib/src/sherpa_onnx_bindings.dart

@@ -677,6 +677,17 @@ final class SherpaOnnxSpokenLanguageIdentificationResult extends Struct {
   external Pointer<Utf8> lang;
 }
 
+final class SherpaOnnxVocabLogProbs extends Struct {
+  // Flattened 2D array
+  external Pointer<Float> logProbs;
+
+  @Int32()
+  external int numTokens;
+
+  @Int32()
+  external int vocabSize;
+}
+
 final class SherpaOnnxSpokenLanguageIdentification extends Opaque {}
 
 final class SherpaOnnxOfflineSpeechDenoiser extends Opaque {}
@@ -1419,6 +1430,20 @@ typedef SherpaOnnxGetGitSha1 = SherpaOnnxGetGitSha1Native;
 typedef SherpaOnnxGetGitDateNative = Pointer<Utf8> Function();
 typedef SherpaOnnxGetGitDate = SherpaOnnxGetGitDateNative;
 
+typedef SherpaOnnxOnlineStreamGetVocabLogProbsNative
+    = Pointer<SherpaOnnxVocabLogProbs> Function(
+        Pointer<SherpaOnnxOnlineStream> stream);
+
+typedef SherpaOnnxOfflineStreamGetVocabLogProbsNative
+    = Pointer<SherpaOnnxVocabLogProbs> Function(
+        Pointer<SherpaOnnxOfflineStream> stream);
+
+typedef SherpaOnnxDestroyVocabLogProbsNative = Void Function(
+    Pointer<SherpaOnnxVocabLogProbs> logProbs);
+
+typedef SherpaOnnxDestroyVocabLogProbsDart = void Function(
+    Pointer<SherpaOnnxVocabLogProbs>);
+
 class SherpaOnnxBindings {
   static SherpaOnnxCreateOfflineSpeechDenoiser?
       sherpaOnnxCreateOfflineSpeechDenoiser;
@@ -1644,6 +1669,12 @@ class SherpaOnnxBindings {
   static SherpaOnnxGetGitSha1? getGitSha1;
   static SherpaOnnxGetGitDate? getGitDate;
 
+  static SherpaOnnxOnlineStreamGetVocabLogProbsNative?
+      getOnlineStreamVocabLogProbs;
+  static SherpaOnnxOfflineStreamGetVocabLogProbsNative?
+      getOfflineStreamVocabLogProbs;
+  static SherpaOnnxDestroyVocabLogProbsDart? destroyVocabLogProbs;
+
   static void init(DynamicLibrary dynamicLibrary) {
     sherpaOnnxCreateOfflineSpeechDenoiser ??= dynamicLibrary
         .lookup<NativeFunction<SherpaOnnxCreateOfflineSpeechDenoiserNative>>(
@@ -2290,5 +2321,23 @@ class SherpaOnnxBindings {
         .lookup<NativeFunction<SherpaOnnxGetGitDateNative>>(
             'SherpaOnnxGetGitDate')
         .asFunction();
+
+    getOnlineStreamVocabLogProbs = dynamicLibrary.lookupFunction<
+        SherpaOnnxOnlineStreamGetVocabLogProbsNative,
+        SherpaOnnxOnlineStreamGetVocabLogProbsNative>(
+      'SherpaOnnxOnlineStreamGetVocabLogProbs',
+    );
+
+    getOfflineStreamVocabLogProbs = dynamicLibrary.lookupFunction<
+        SherpaOnnxOfflineStreamGetVocabLogProbsNative,
+        SherpaOnnxOfflineStreamGetVocabLogProbsNative>(
+      'SherpaOnnxOfflineStreamGetVocabLogProbs',
+    );
+
+    destroyVocabLogProbs = dynamicLibrary.lookupFunction<
+        SherpaOnnxDestroyVocabLogProbsNative,
+        SherpaOnnxDestroyVocabLogProbsDart>(
+      'SherpaOnnxDestroyVocabLogProbs',
+    );
   }
 }

flutter/sherpa_onnx/pubspec.yaml

@@ -39,6 +39,7 @@ dependencies:
   #   path: ../sherpa_onnx_macos
 
   sherpa_onnx_linux: ^1.12.19
+  # Use local path for development, uncomment below for local development
   # sherpa_onnx_linux:
   #   path: ../sherpa_onnx_linux
 

sherpa-onnx/c-api/c-api.cc

@@ -754,6 +754,65 @@ const char *SherpaOnnxGetOfflineStreamResultAsJson(
 
 void SherpaOnnxDestroyOfflineStreamResultJson(const char *s) { delete[] s; }
 
+const struct SherpaOnnxVocabLogProbs *SherpaOnnxOnlineStreamGetVocabLogProbs(
+    const SherpaOnnxOnlineStream *stream) {
+  const auto &result = stream->impl->GetResult();
+
+  if (result.vocab_log_probs.empty()) {
+    return nullptr;
+  }
+
+  auto vocab_probs = new SherpaOnnxVocabLogProbs;
+  vocab_probs->num_tokens = result.vocab_log_probs.size();
+  vocab_probs->vocab_size = result.vocab_log_probs[0].size();
+
+  // Flatten the 2D vector into a 1D array
+  float *flat_probs =
+      new float[vocab_probs->num_tokens * vocab_probs->vocab_size];
+  for (int32_t i = 0; i < vocab_probs->num_tokens; ++i) {
+    std::copy(result.vocab_log_probs[i].begin(),
+              result.vocab_log_probs[i].end(),
+              flat_probs + i * vocab_probs->vocab_size);
+  }
+  vocab_probs->log_probs = flat_probs;
+
+  return vocab_probs;
+}
+
+const struct SherpaOnnxVocabLogProbs *SherpaOnnxOfflineStreamGetVocabLogProbs(
+    const SherpaOnnxOfflineStream *stream) {
+  const sherpa_onnx::OfflineRecognitionResult &result =
+      stream->impl->GetResult();
+
+  if (result.vocab_log_probs.empty()) {
+    return nullptr;
+  }
+
+  auto vocab_probs = new SherpaOnnxVocabLogProbs;
+  vocab_probs->num_tokens = result.vocab_log_probs.size();
+  vocab_probs->vocab_size = result.vocab_log_probs[0].size();
+
+  // Flatten the 2D vector into a 1D array
+  float *flat_probs =
+      new float[vocab_probs->num_tokens * vocab_probs->vocab_size];
+  for (int32_t i = 0; i < vocab_probs->num_tokens; ++i) {
+    std::copy(result.vocab_log_probs[i].begin(),
+              result.vocab_log_probs[i].end(),
+              flat_probs + i * vocab_probs->vocab_size);
+  }
+  vocab_probs->log_probs = flat_probs;
+
+  return vocab_probs;
+}
+
+void SherpaOnnxDestroyVocabLogProbs(
+    const struct SherpaOnnxVocabLogProbs *log_probs) {
+  if (log_probs) {
+    delete[] log_probs->log_probs;
+    delete log_probs;
+  }
+}
+
 // ============================================================
 // For Keyword Spot
 // ============================================================

sherpa-onnx/c-api/c-api.h

@@ -673,6 +673,21 @@ SHERPA_ONNX_API typedef struct SherpaOnnxOfflineRecognizerResult {
   float *ys_log_probs;
 } SherpaOnnxOfflineRecognizerResult;
 
+SHERPA_ONNX_API typedef struct SherpaOnnxVocabLogProbs {
+  const float *log_probs;  // Flattened 2D array [num_tokens][vocab_size]
+  int32_t num_tokens;
+  int32_t vocab_size;
+} SherpaOnnxVocabLogProbs;
+
+SHERPA_ONNX_API const SherpaOnnxVocabLogProbs *
+SherpaOnnxOnlineStreamGetVocabLogProbs(const SherpaOnnxOnlineStream *stream);
+
+SHERPA_ONNX_API const SherpaOnnxVocabLogProbs *
+SherpaOnnxOfflineStreamGetVocabLogProbs(const SherpaOnnxOfflineStream *stream);
+
+SHERPA_ONNX_API void SherpaOnnxDestroyVocabLogProbs(
+    const SherpaOnnxVocabLogProbs *log_probs);
+
 /// Get the result of the offline stream.
 ///
 /// We assume you have called SherpaOnnxDecodeOfflineStream() or

sherpa-onnx/csrc/offline-ctc-decoder.h

@@ -26,6 +26,11 @@ struct OfflineCtcDecoderResult {
   ///
   /// tokens.size() == timestamps.size()
   std::vector<int32_t> timestamps;
+
+  /// Token-level log probabilities (confidence scores).
+  /// May be empty if not provided by the decoder.
+  /// If populated, token_log_probs.size() == tokens.size()
+  std::vector<float> token_log_probs;
 };
 
 class OfflineCtcDecoder {

sherpa-onnx/csrc/offline-moonshine-decoder.h

@@ -14,6 +14,9 @@ namespace sherpa_onnx {
 struct OfflineMoonshineDecoderResult {
   /// The decoded token IDs
   std::vector<int32_t> tokens;
+  /// Token-level log probabilities (confidence scores)
+  std::vector<float> token_log_probs;
+  std::vector<std::vector<float>> vocab_log_probs;
 };
 
 class OfflineMoonshineDecoder {