Expose token + vocab log probabilities from offline CTC decoder

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

@@ -865,6 +865,24 @@ const SherpaOnnxOfflineRecognizerResult *SherpaOnnxGetOfflineStreamResult(
     r->ys_log_probs = nullptr;
   }
 
+  // Copy vocab_log_probs (flattened row-major: count * vocab_size)
+  if (!result.vocab_log_probs.empty() &&
+      static_cast<int32_t>(result.vocab_log_probs.size()) == r->count &&
+      !result.vocab_log_probs[0].empty()) {
+    int32_t vocab_size =
+        static_cast<int32_t>(result.vocab_log_probs[0].size());
+    r->vocab_size = vocab_size;
+    float *flat = new float[r->count * vocab_size];
+    for (int32_t i = 0; i < r->count; ++i) {
+      std::copy(result.vocab_log_probs[i].begin(),
+                result.vocab_log_probs[i].end(), flat + i * vocab_size);
+    }
+    r->vocab_log_probs = flat;
+  } else {
+    r->vocab_log_probs = nullptr;
+    r->vocab_size = 0;
+  }
+
   // Copy segment-level timestamps (from Whisper with segment timestamps)
   auto segment_count = result.segment_texts.size();
   if (segment_count > 0 && result.segment_timestamps.size() == segment_count &&
@@ -908,6 +926,8 @@ const SherpaOnnxOfflineRecognizerResult *SherpaOnnxGetOfflineStreamResult(
     r->segment_texts_arr = nullptr;
   }
 
+  // NB: vocab_log_probs / vocab_size are set above (before the segment block).
+
   return r;
 }
 
@@ -928,6 +948,7 @@ void SherpaOnnxDestroyOfflineRecognizerResult(
     delete[] r->segment_durations;
     delete[] r->segment_texts;
     delete[] r->segment_texts_arr;
+    delete[] r->vocab_log_probs;
     delete r;
   }
 }

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

@@ -1517,6 +1517,21 @@ typedef struct SherpaOnnxOfflineRecognizerResult {
 
   /** Number of segment entries in the segment-level arrays. */
   int32_t segment_count;
+
+  /**
+   * Optional flattened vocabulary log-probability matrix.
+   *
+   * When non-NULL, this is a contiguous row-major array of
+   * @c count * @c vocab_size floats. Row @c i (starting at offset
+   * <code>i * vocab_size</code>) holds the full log-probability distribution
+   * over the vocabulary for the @c i-th emitted token.
+   *
+   * Used for entropy-based confidence estimation.
+   */
+  const float *vocab_log_probs;
+
+  /** Vocabulary size (number of columns in @c vocab_log_probs). */
+  int32_t vocab_size;
 } SherpaOnnxOfflineRecognizerResult;
 
 /**

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

@@ -26,6 +26,17 @@ struct OfflineCtcDecoderResult {
   ///
   /// tokens.size() == timestamps.size()
   std::vector<int32_t> timestamps;
+
+  /// Greedy log-probability of tokens[i] (i.e. log p(tokens[i] | frame)).
+  /// Empty when the decoder did not record it.
+  /// If populated, token_log_probs.size() == tokens.size().
+  std::vector<float> token_log_probs;
+
+  /// Full vocabulary log-probability distribution at the emission frame of
+  /// tokens[i]. vocab_log_probs[i].size() == vocab_size.
+  /// Empty when the decoder did not record it.
+  /// If populated, vocab_log_probs.size() == tokens.size().
+  std::vector<std::vector<float>> vocab_log_probs;
 };
 
 class OfflineCtcDecoder {

sherpa-onnx/csrc/offline-ctc-greedy-search-decoder.cc

@@ -37,12 +37,15 @@ std::vector<OfflineCtcDecoderResult> OfflineCtcGreedySearchDecoder::Decode(
           std::max_element(
               static_cast<const float *>(p_log_probs),
               static_cast<const float *>(p_log_probs) + vocab_size)));
-      p_log_probs += vocab_size;
+      float log_prob = p_log_probs[y];
 
       if (y != blank_id_ && y != prev_id) {
         r.tokens.push_back(y);
         r.timestamps.push_back(t);
+        r.token_log_probs.push_back(log_prob);
+        r.vocab_log_probs.emplace_back(p_log_probs, p_log_probs + vocab_size);
       }
+      p_log_probs += vocab_size;
       prev_id = y;
     }  // for (int32_t t = 0; ...)
 

sherpa-onnx/csrc/offline-recognizer-ctc-impl.h

@@ -77,6 +77,16 @@ OfflineRecognitionResult Convert(const OfflineCtcDecoderResult &src,
 
   r.words = std::move(src.words);
 
+  if (!src.token_log_probs.empty() &&
+      src.token_log_probs.size() == src.tokens.size()) {
+    r.ys_log_probs = src.token_log_probs;
+  }
+
+  if (!src.vocab_log_probs.empty() &&
+      src.vocab_log_probs.size() == src.tokens.size()) {
+    r.vocab_log_probs = src.vocab_log_probs;
+  }
+
   return r;
 }
 

sherpa-onnx/csrc/offline-stream.h

@@ -45,6 +45,13 @@ struct OfflineRecognitionResult {
   /// ys_log_probs[i] contains the log probability (confidence) for tokens[i].
   std::vector<float> ys_log_probs;
 
+  /// vocab_log_probs[i] contains the full log-probability distribution over
+  /// the vocabulary at the emission frame of tokens[i]. Used for entropy-based
+  /// confidence estimation. Empty when not provided by the decoder.
+  /// If populated, vocab_log_probs.size() == tokens.size() and every inner
+  /// vector has the same length (the model vocab size).
+  std::vector<std::vector<float>> vocab_log_probs;
+
   // Word IDs from FST decoding (CTC models with FST decoder only).
   std::vector<int32_t> words;