Function bark_forward_fine_encoder

bark.cpp:2110–2159

}

bool bark_forward_fine_encoder(struct bark_context* bctx, int n_threads) {
    const int64_t t_main_start_us = ggml_time_us();

    auto& model = bctx->text_model.fine_model;
    auto& allocr = bctx->allocr;
    auto& hparams = model.hparams;
    auto& params = bctx->params;
    auto& verbosity = bctx->params.verbosity;

    int32_t n_fine_codebooks = params.n_fine_codebooks;

    // allocate the compute buffer
    {
        // alignment required by the backend
        size_t align = ggml_backend_get_alignment(model.backend);
        bctx->allocr = ggml_allocr_new_measure(align);

        // create the worst-case graph for memory usage estimation
        std::vector<bark_vocab::id> decoy_tokens(hparams.block_size * n_fine_codebooks, 0);
        struct ggml_cgraph* gf = bark_build_fine_gpt_graph(
            &model, allocr, decoy_tokens, 2 /* codebook_idx */, n_fine_codebooks, n_threads);

        // compute the required memory
        size_t mem_size = ggml_allocr_alloc_graph(bctx->allocr, gf);

        // recreate the allocator with the required memory
        ggml_allocr_free(bctx->allocr);
        bctx->buf_compute = ggml_backend_alloc_buffer(model.backend, mem_size);
        bctx->allocr = ggml_allocr_new_from_buffer(bctx->buf_compute);

        if (verbosity == bark_verbosity_level::MEDIUM || verbosity == bark_verbosity_level::HIGH) {
            fprintf(stderr, "%s: compute buffer size: %.2f MB\n\n", __func__, mem_size / 1024.0 / 1024.0);
        }
    }

    if (!bark_eval_fine_encoder(bctx, n_threads)) {
        fprintf(stderr, "%s: failed to forward coarse encoder\n", __func__);
        return false;
    }

    model.t_main_us = ggml_time_us() - t_main_start_us;
    bctx->stats.t_fine_us = model.t_main_us;

    bark_print_statistics(&model);

    ggml_backend_buffer_free(bctx->buf_compute);
    ggml_allocr_free(bctx->allocr);

    return true;
}

static bool bark_forward_eval(struct bark_context* bctx, int n_threads) {
    if (!bark_forward_text_encoder(bctx, n_threads)) {