Function select_vibevoice_constrained_token

src/models/vibevoice/generator.cpp:421–503

};

int32_t select_vibevoice_constrained_token(
    const VibeVoiceDecoderLogits & logits,
    const VibeVoiceTextTokenizer & text_tokenizer,
    const VibeVoiceGenerationOptions & options,
    std::mt19937 & rng) {
    if (logits.vocab_size <= 0 || static_cast<int64_t>(logits.values.size()) != logits.vocab_size) {
        throw std::runtime_error("VibeVoice constrained token selection received invalid logits");
    }
    const int32_t candidates[] = {
        text_tokenizer.speech_start_id(),
        text_tokenizer.speech_end_id(),
        text_tokenizer.speech_diffusion_id(),
        text_tokenizer.eos_id(),
    };
    int32_t best_token = candidates[0];
    float best_score = -std::numeric_limits<float>::infinity();
    for (const int32_t token : candidates) {
        if (token < 0 || token >= logits.vocab_size) {
            throw std::runtime_error("VibeVoice constrained token candidate is outside logits vocabulary");
        }
        const float score = logits.values[static_cast<size_t>(token)];
        if (score > best_score) {
            best_score = score;
            best_token = token;
        }
    }
    if (!options.do_sample) {
        return best_token;
    }
    if (!(options.temperature > 0.0F) || !std::isfinite(options.temperature)) {
        throw std::runtime_error("VibeVoice sampler temperature must be finite and positive");
    }
    if (options.top_k < 0) {
        throw std::runtime_error("VibeVoice sampler top_k must be non-negative");
    }
    if (!(options.top_p > 0.0F && options.top_p <= 1.0F) || !std::isfinite(options.top_p)) {
        throw std::runtime_error("VibeVoice sampler top_p must be finite and in (0, 1]");
    }
    auto candidate_order = [](const VibeVoiceSamplingCandidate & lhs, const VibeVoiceSamplingCandidate & rhs) {
        if (lhs.score == rhs.score) {
            return lhs.token < rhs.token;
        }
        return lhs.score > rhs.score;
    };
    std::vector<VibeVoiceSamplingCandidate> scores;
    scores.reserve(sizeof(candidates) / sizeof(candidates[0]));
    for (const int32_t token : candidates) {
        scores.push_back({token, logits.values[static_cast<size_t>(token)] / options.temperature});
    }
    if (options.top_k > 0 && static_cast<size_t>(options.top_k) < scores.size()) {
        const auto top_end = scores.begin() + static_cast<std::ptrdiff_t>(options.top_k);
        std::nth_element(scores.begin(), top_end, scores.end(), candidate_order);
        std::sort(scores.begin(), top_end, candidate_order);
        scores.erase(top_end, scores.end());
    } else {
        std::sort(scores.begin(), scores.end(), candidate_order);
    }
    const float max_score = scores.front().score;