cohere-transcribe 0.1.0

data/vendor/crispasr/src/cohere_frontend.cpp

@@ -0,0 +1,189 @@
+#include "cohere_frontend.h"
+
+#include <algorithm>
+#include <cmath>
+#include <cstdint>
+#include <random>
+
+namespace cohere_frontend {
+namespace {
+
+constexpr double kPi = 3.141592653589793238462643383279502884;
+
+std::vector<float> make_nonperiodic_hann(int length) {
+    if (length <= 0)
+        return {};
+    if (length == 1)
+        return {1.0f};
+
+    // torch.hann_window(..., periodic=false, dtype=float32) evaluates the
+    // phase in FP32. Keeping every operand float reproduces that behavior,
+    // including its tiny endpoint-asymmetry from phase rounding.
+    constexpr float pi_f = (float)kPi;
+    std::vector<float> window((size_t)length);
+    for (int i = 0; i < length; ++i) {
+        const float phase = 2.0f * pi_f * (float)i / (float)(length - 1);
+        window[(size_t)i] = 0.5f * (1.0f - std::cos(phase));
+    }
+    return window;
+}
+
+std::vector<float> make_librosa_slaney_filters(int sample_rate, int n_fft, int n_mels) {
+    if (sample_rate <= 0 || n_fft <= 0 || n_mels <= 0)
+        return {};
+
+    const int n_freqs = n_fft / 2 + 1;
+    const double fmin = 0.0;
+    const double fmax = (double)sample_rate / 2.0;
+    const double f_sp = 200.0 / 3.0;
+    const double min_log_hz = 1000.0;
+    const double min_log_mel = min_log_hz / f_sp;
+    const double logstep = std::log(6.4) / 27.0;
+
+    auto hz_to_mel = [&](double hz) {
+        return hz >= min_log_hz ? min_log_mel + std::log(hz / min_log_hz) / logstep : hz / f_sp;
+    };
+    auto mel_to_hz = [&](double mel) {
+        return mel >= min_log_mel ? min_log_hz * std::exp(logstep * (mel - min_log_mel)) : f_sp * mel;
+    };
+
+    // librosa computes its frequency grid and mel centers in float64, writes
+    // each unnormalized triangle to a float32 output row, then applies the
+    // float64 Slaney area scale in-place (casting the result back to FP32).
+    const double mel_min = hz_to_mel(fmin);
+    const double mel_max = hz_to_mel(fmax);
+    const double mel_step = (mel_max - mel_min) / (double)(n_mels + 1);
+    std::vector<double> centers((size_t)n_mels + 2);
+    for (int i = 0; i < n_mels + 2; ++i)
+        centers[(size_t)i] = mel_to_hz(mel_min + mel_step * (double)i);
+    centers.back() = fmax; // np.linspace includes the stop value exactly.
+
+    std::vector<float> filters((size_t)n_mels * n_freqs, 0.0f);
+    for (int m = 0; m < n_mels; ++m) {
+        const double lo = centers[(size_t)m];
+        const double mid = centers[(size_t)m + 1];
+        const double hi = centers[(size_t)m + 2];
+        const double area_scale = 2.0 / (hi - lo);
+        for (int k = 0; k < n_freqs; ++k) {
+            const double hz = (double)k * (double)sample_rate / (double)n_fft;
+            const double lower = (hz - lo) / (mid - lo);
+            const double upper = (hi - hz) / (hi - mid);
+            const float triangle = (float)std::max(0.0, std::min(lower, upper));
+            filters[(size_t)m * n_freqs + k] = (float)((double)triangle * area_scale);
+        }
+    }
+    return filters;
+}
+
+inline float torch_uniform_float(std::mt19937& generator) {
+    // at::uniform_real_distribution<float>: keep the lower 24 bits and
+    // scale by 2^-24, yielding [0, 1).
+    constexpr uint32_t mask = (1u << 24) - 1u;
+    constexpr float scale = 1.0f / (float)(1u << 24);
+    return (float)(generator() & mask) * scale;
+}
+
+inline double torch_uniform_double(std::mt19937& generator) {
+    // CPUGeneratorImpl::random64 concatenates two consecutive MT outputs,
+    // then uniform_real_distribution<double> keeps the lower 53 bits.
+    constexpr uint64_t mask = (1ull << 53) - 1ull;
+    constexpr double scale = 1.0 / (double)(1ull << 53);
+    const uint64_t value = ((uint64_t)generator() << 32) | generator();
+    return (double)(value & mask) * scale;
+}
+
+void box_muller_16(float* values) {
+    constexpr float two_pi = (float)(2.0 * kPi);
+    for (int j = 0; j < 8; ++j) {
+        const float u1 = 1.0f - values[j]; // [0,1) -> (0,1] before log
+        const float u2 = values[j + 8];
+        const float radius = std::sqrt(-2.0f * std::log(u1));
+        const float theta = two_pi * u2;
+        values[j] = radius * std::cos(theta);
+        values[j + 8] = radius * std::sin(theta);
+    }
+}
+
+std::vector<float> length_seeded_normal(int valid_samples) {
+    std::vector<float> values((size_t)std::max(valid_samples, 0));
+    if (valid_samples <= 0)
+        return values;
+
+    // CPUGeneratorImpl's mt19937 sequence matches std::mt19937 for a 32-bit
+    // seed. torch.randn first fills the entire contiguous tensor with uniform
+    // values, transforms complete groups of 16, then regenerates/recomputes
+    // the final 16 values when the length has a remainder.
+    std::mt19937 generator((uint32_t)valid_samples);
+    for (float& value : values)
+        value = torch_uniform_float(generator);
+
+    if (valid_samples < 16) {
+        // PyTorch dispatches short contiguous tensors through its scalar
+        // double-precision Box-Muller path and caches the second sample.
+        generator.seed((uint32_t)valid_samples);
+        bool have_cached = false;
+        double cached = 0.0;
+        for (float& value : values) {
+            if (have_cached) {
+                value = (float)cached;
+                have_cached = false;
+                continue;
+            }
+            const double u1 = torch_uniform_double(generator);
+            const double u2 = torch_uniform_double(generator);
+            const double radius = std::sqrt(-2.0 * std::log1p(-u2));
+            const double theta = 2.0 * kPi * u1;
+            value = (float)(radius * std::cos(theta));
+            cached = radius * std::sin(theta);
+            have_cached = true;
+        }
+        return values;
+    }
+
+    for (int i = 0; i < valid_samples - 15; i += 16)
+        box_muller_16(values.data() + i);
+
+    if (valid_samples % 16 != 0) {
+        float* tail = values.data() + valid_samples - 16;
+        for (int i = 0; i < 16; ++i)
+            tail[i] = torch_uniform_float(generator);
+        box_muller_16(tail);
+    }
+    return values;
+}
+
+} // namespace
+
+Constants make_constants(int sample_rate, int n_fft, int win_length, int n_mels) {
+    Constants constants;
+    constants.window = make_nonperiodic_hann(win_length);
+    constants.mel_filters = make_librosa_slaney_filters(sample_rate, n_fft, n_mels);
+    return constants;
+}
+
+std::vector<float> dither_and_preemphasize(const float* samples, int valid_samples, float dither,
+                                           float preemphasis) {
+    if (!samples || valid_samples <= 0)
+        return {};
+
+    std::vector<float> waveform(samples, samples + valid_samples);
+    if (dither > 0.0f) {
+        auto noise = length_seeded_normal(valid_samples);
+        for (int i = 0; i < valid_samples; ++i) {
+            const float scaled_noise = dither * noise[(size_t)i];
+            waveform[(size_t)i] += scaled_noise;
+        }
+    }
+
+    // Work backwards so the source sample at i-1 is still the original
+    // dithered waveform, matching torch.cat([x[:1], x[1:]-a*x[:-1]]).
+    if (preemphasis != 0.0f) {
+        for (int i = valid_samples - 1; i >= 1; --i) {
+            const float previous = preemphasis * waveform[(size_t)i - 1];
+            waveform[(size_t)i] -= previous;
+        }
+    }
+    return waveform;
+}
+
+} // namespace cohere_frontend

data/vendor/crispasr/src/cohere_frontend.h

@@ -0,0 +1,31 @@
+// Cohere ASR frontend constants and waveform preparation.
+//
+// These values are generated at runtime because the checkpoint stores the
+// filterbank/window in reduced precision. The implementation mirrors the HF
+// CohereAsrFeatureExtractor contract without depending on PyTorch or librosa.
+
+#pragma once
+
+#include <vector>
+
+namespace cohere_frontend {
+
+struct Constants {
+    // FP32 non-periodic Hann window, length win_length.
+    std::vector<float> window;
+
+    // FP32 librosa-compatible Slaney filterbank in [n_mels, n_fft/2+1]
+    // row-major layout.
+    std::vector<float> mel_filters;
+};
+
+Constants make_constants(int sample_rate, int n_fft, int win_length, int n_mels);
+
+// Add deterministic N(0, dither^2) noise using valid_samples as the seed,
+// then apply y[0]=x[0], y[i]=x[i]-preemphasis*x[i-1]. PyTorch's CPU RNG
+// stream and 16-value Box-Muller grouping are reproduced; portable scalar
+// libm replaces PyTorch's architecture-specific vector math.
+std::vector<float> dither_and_preemphasize(const float* samples, int valid_samples, float dither,
+                                           float preemphasis);
+
+} // namespace cohere_frontend

data/vendor/crispasr/src/cohere_ragged_controller.h

@@ -0,0 +1,149 @@
+#pragma once
+
+#include <cmath>
+#include <cstddef>
+#include <vector>
+
+namespace cohere_ragged {
+
+enum class stop_reason {
+    active,
+    eos,
+    max_tokens,
+};
+
+enum class step_result {
+    advanced,
+    complete,
+    invalid_input,
+    already_complete,
+};
+
+struct generated_token {
+    int token_id = 0;
+    float probability = 0.0f;
+
+    generated_token() = default;
+    generated_token(int token_id_value, float probability_value)
+        : token_id(token_id_value), probability(probability_value) {
+    }
+};
+
+struct lane_result {
+    stop_reason reason = stop_reason::active;
+    std::size_t max_tokens = 0;
+    std::vector<generated_token> generated;
+};
+
+// Host-side greedy-generation state for a fixed physical decoder batch. Lanes
+// remain at their original indices for the controller's lifetime; completed
+// lanes feed placeholder_token_id while active lanes feed their latest token.
+class controller {
+  public:
+    controller(int eos_token_id, int placeholder_token_id, const std::vector<std::size_t>& max_tokens)
+        : eos_token_id_(eos_token_id), placeholder_token_id_(placeholder_token_id),
+          valid_(eos_token_id >= 0 && placeholder_token_id >= 0 && !max_tokens.empty()) {
+        if (!valid_)
+            return;
+
+        feed_tokens_.assign(max_tokens.size(), placeholder_token_id_);
+        results_.reserve(max_tokens.size());
+        for (std::size_t limit : max_tokens) {
+            lane_result lane;
+            lane.max_tokens = limit;
+            if (limit == 0)
+                lane.reason = stop_reason::max_tokens;
+            else
+                ++active_count_;
+            results_.push_back(lane);
+        }
+    }
+
+    bool valid() const {
+        return valid_;
+    }
+
+    bool done() const {
+        return valid_ && active_count_ == 0;
+    }
+
+    std::size_t lane_count() const {
+        return results_.size();
+    }
+
+    std::size_t active_count() const {
+        return active_count_;
+    }
+
+    int eos_token_id() const {
+        return eos_token_id_;
+    }
+
+    int placeholder_token_id() const {
+        return placeholder_token_id_;
+    }
+
+    const std::vector<int>& feed_tokens() const {
+        return feed_tokens_;
+    }
+
+    const std::vector<lane_result>& results() const {
+        return results_;
+    }
+
+    step_result apply_step(const std::vector<int>& token_ids, const std::vector<float>& probabilities) {
+        if (token_ids.size() != probabilities.size())
+            return step_result::invalid_input;
+        return apply_step(token_ids.data(), probabilities.data(), token_ids.size());
+    }
+
+    step_result apply_step(const int* token_ids, const float* probabilities, std::size_t count) {
+        if (!valid_ || !token_ids || !probabilities || count != results_.size())
+            return step_result::invalid_input;
+        if (done())
+            return step_result::already_complete;
+
+        // Validate the whole physical batch before mutating any lane.
+        for (std::size_t lane = 0; lane < count; ++lane) {
+            const float probability = probabilities[lane];
+            if (token_ids[lane] < 0 || !std::isfinite((double)probability) || probability < 0.0f ||
+                probability > 1.0f)
+                return step_result::invalid_input;
+        }
+
+        for (std::size_t lane = 0; lane < count; ++lane) {
+            lane_result& result = results_[lane];
+            if (result.reason != stop_reason::active)
+                continue;
+
+            const int token_id = token_ids[lane];
+            if (token_id == eos_token_id_) {
+                result.reason = stop_reason::eos;
+                feed_tokens_[lane] = placeholder_token_id_;
+                --active_count_;
+                continue;
+            }
+
+            result.generated.push_back(generated_token(token_id, probabilities[lane]));
+            if (result.generated.size() >= result.max_tokens) {
+                result.reason = stop_reason::max_tokens;
+                feed_tokens_[lane] = placeholder_token_id_;
+                --active_count_;
+            } else {
+                feed_tokens_[lane] = token_id;
+            }
+        }
+
+        return done() ? step_result::complete : step_result::advanced;
+    }
+
+  private:
+    int eos_token_id_ = 0;
+    int placeholder_token_id_ = 0;
+    bool valid_ = false;
+    std::size_t active_count_ = 0;
+    std::vector<int> feed_tokens_;
+    std::vector<lane_result> results_;
+};
+
+} // namespace cohere_ragged

data/vendor/crispasr/src/cohere_token_renderer.h

@@ -0,0 +1,181 @@
+#pragma once
+
+#include <algorithm>
+#include <cstddef>
+#include <string>
+#include <vector>
+
+namespace cohere_token_renderer {
+
+constexpr int speaker_token_count = 16;
+
+struct speaker_token_ids {
+    int change = -1;
+    int first_speaker = -1;
+};
+
+struct token_record {
+    int id = -1;
+    float probability = 0.0f;
+    int generated_index = -1;
+    std::string text;
+};
+
+enum class render_error {
+    none,
+    probability_count_mismatch,
+};
+
+struct render_result {
+    render_error error = render_error::none;
+    std::string full_text;
+    std::vector<token_record> tokens;
+
+    bool ok() const {
+        return error == render_error::none;
+    }
+};
+
+namespace detail {
+
+inline int hex_nibble(char value) {
+    if (value >= '0' && value <= '9')
+        return value - '0';
+    if (value >= 'A' && value <= 'F')
+        return 10 + value - 'A';
+    if (value >= 'a' && value <= 'f')
+        return 10 + value - 'a';
+    return -1;
+}
+
+inline bool byte_fallback_value(const std::string& piece, unsigned char& byte) {
+    if (piece.size() != 6 || piece[0] != '<' || piece[1] != '0' || piece[2] != 'x' || piece[5] != '>')
+        return false;
+    const int high = hex_nibble(piece[3]);
+    const int low = hex_nibble(piece[4]);
+    if (high < 0 || low < 0)
+        return false;
+    byte = (unsigned char)((high << 4) | low);
+    return true;
+}
+
+inline int utf8_expected_length(unsigned char lead) {
+    if ((lead & 0x80) == 0)
+        return 1;
+    if ((lead & 0xE0) == 0xC0)
+        return 2;
+    if ((lead & 0xF0) == 0xE0)
+        return 3;
+    if ((lead & 0xF8) == 0xF0)
+        return 4;
+    return 0;
+}
+
+inline bool is_complete_utf8(const std::string& bytes) {
+    if (bytes.empty())
+        return false;
+    const int expected = utf8_expected_length((unsigned char)bytes[0]);
+    if (expected <= 0 || (int)bytes.size() != expected)
+        return false;
+    for (int index = 1; index < expected; ++index) {
+        if ((((unsigned char)bytes[(size_t)index]) & 0xC0) != 0x80)
+            return false;
+    }
+    return true;
+}
+
+inline bool is_speaker_id(int id, int first_speaker) {
+    if (first_speaker < 0 || id < first_speaker)
+        return false;
+    return (long long)id - (long long)first_speaker < speaker_token_count;
+}
+
+} // namespace detail
+
+// Decode generated Cohere IDs without depending on a model context. Byte
+// fallback pieces are collapsed into one rendered record per complete UTF-8
+// sequence. The record keeps the first byte's ID, the minimum probability,
+// and the last byte's generated index, matching the production decoder.
+inline render_result render(const std::vector<int>& generated_ids, const std::vector<float>& probabilities,
+                            const std::vector<std::string>& vocabulary_pieces,
+                            const speaker_token_ids& speaker_tokens) {
+    render_result result;
+    if (generated_ids.size() != probabilities.size()) {
+        result.error = render_error::probability_count_mismatch;
+        return result;
+    }
+
+    auto emit = [&](int id, float probability, int generated_index, const std::string& text) {
+        result.tokens.push_back({id, probability, generated_index, text});
+        result.full_text += text;
+    };
+
+    std::string pending_bytes;
+    int pending_id = -1;
+    int pending_generated_index = -1;
+    float pending_probability = 1.0f;
+
+    auto flush_pending = [&]() {
+        if (pending_bytes.empty())
+            return;
+        if (detail::is_complete_utf8(pending_bytes))
+            emit(pending_id, pending_probability, pending_generated_index, pending_bytes);
+        pending_bytes.clear();
+        pending_id = -1;
+        pending_generated_index = -1;
+        pending_probability = 1.0f;
+    };
+
+    for (size_t generated_index = 0; generated_index < generated_ids.size(); ++generated_index) {
+        const int id = generated_ids[generated_index];
+        if (id < 0 || (size_t)id >= vocabulary_pieces.size())
+            continue;
+
+        const std::string& piece = vocabulary_pieces[(size_t)id];
+        unsigned char byte = 0;
+        if (detail::byte_fallback_value(piece, byte)) {
+            if (pending_bytes.empty()) {
+                pending_id = id;
+                pending_generated_index = (int)generated_index;
+                pending_probability = probabilities[generated_index];
+            } else {
+                pending_probability = std::min(pending_probability, probabilities[generated_index]);
+                pending_generated_index = (int)generated_index;
+            }
+            pending_bytes.push_back((char)byte);
+            if (detail::is_complete_utf8(pending_bytes))
+                flush_pending();
+            continue;
+        }
+
+        flush_pending();
+        if (piece.empty())
+            continue;
+
+        std::string text;
+        if (piece.front() == '<' && piece.back() == '>') {
+            if (id == speaker_tokens.change) {
+                text = " [SPEAKER_TURN]";
+            } else if (detail::is_speaker_id(id, speaker_tokens.first_speaker)) {
+                text = " [Speaker " + std::to_string(id - speaker_tokens.first_speaker) + "]";
+            } else {
+                continue;
+            }
+        } else {
+            text = piece;
+            const std::string boundary = "\xE2\x96\x81";
+            size_t position = 0;
+            while ((position = text.find(boundary)) != std::string::npos)
+                text.replace(position, boundary.size(), " ");
+        }
+
+        emit(id, probabilities[generated_index], (int)generated_index, text);
+    }
+
+    flush_pending();
+    if (!result.full_text.empty() && result.full_text.front() == ' ')
+        result.full_text.erase(result.full_text.begin());
+    return result;
+}
+
+} // namespace cohere_token_renderer