Method decoder_cached_step

src/models/heartmula/mula.cpp:2012–2060

}

HeartMuLaDecoderResult HeartMuLaWeightsRuntime::decoder_cached_step(
    const std::vector<float> & embedding,
    int64_t batch_size,
    int64_t codebook_index,
    HeartMuLaDecoderCachedState & state,
    int64_t cache_capacity) const {
    const auto & full_config = assets_->mula_config;
    if (batch_size <= 0) {
        throw std::runtime_error("HeartMuLa decoder cached step requires positive batch size");
    }
    if (cache_capacity <= 0) {
        throw std::runtime_error("HeartMuLa decoder cached step requires positive cache capacity");
    }
    if (cache_capacity > full_config.decoder.max_seq_len) {
        throw std::runtime_error("HeartMuLa decoder cached step exceeds model context length");
    }
    if (codebook_index < 0 || codebook_index >= full_config.audio_num_codebooks - 1) {
        throw std::runtime_error("HeartMuLa decoder cached step codebook index is out of range");
    }
    if (static_cast<int64_t>(embedding.size()) != batch_size * full_config.backbone.embed_dim) {
        throw std::runtime_error("HeartMuLa decoder cached step embedding payload size mismatch");
    }
    const int64_t current_end = state.graph_has_state_ && decoder_cached_step_graph_ != nullptr
        ? decoder_cached_step_graph_->current_end()
        : state.pending_state_.current_end;
    const int64_t required_capacity = std::max<int64_t>(cache_capacity, current_end + 1);
    if (required_capacity > full_config.decoder.max_seq_len) {
        throw std::runtime_error("HeartMuLa decoder cached step capacity exceeds model context length");
    }
    if (decoder_cached_step_graph_ != nullptr && state.graph_has_state_ &&
        !decoder_cached_step_graph_->can_run(*this, batch_size, required_capacity)) {
        state.pending_state_ = decoder_cached_step_graph_->export_state();
        state.graph_has_state_ = false;
    }
    if (decoder_cached_step_graph_ == nullptr ||
        !decoder_cached_step_graph_->can_run(*this, batch_size, required_capacity)) {
        decoder_cached_step_graph_.reset();
        decoder_cached_step_graph_ = std::make_unique<HeartMuLaDecoderCachedStepGraph>(
            *this,
            batch_size,
            required_capacity);
    }
    if (!state.graph_has_state_) {
        decoder_cached_step_graph_->import_state(state.pending_state_);
        state.pending_state_ = {};
        state.graph_has_state_ = true;
    }
    return decoder_cached_step_graph_->run_step(embedding, codebook_index);
}

HeartMuLaMergedEmbeddings HeartMuLaWeightsRuntime::merge_frame_embeddings(
    const HeartMuLaFrameEmbeddingInputs & inputs) const {