Function bark_eval_text_encoder

bark.cpp:1682–1740

}

static bool bark_eval_text_encoder(struct bark_context* bctx, int n_threads) {
    bark_sequence input = bctx->tokens;
    bark_sequence output;

    auto& params = bctx->params;

    int32_t n_steps_text_encoder = params.n_steps_text_encoder;
    int32_t semantic_vocab_size = params.semantic_vocab_size;
    int32_t semantic_pad_token = params.semantic_pad_token;

    auto& model = bctx->text_model.semantic_model;
    auto& allocr = bctx->allocr;
    auto& hparams = model.hparams;

    const int n_vocab = hparams.n_out_vocab;

    float min_eos_p = bctx->params.min_eos_p;
    float temp = bctx->params.temp;

    std::vector<float> logits;
    logits.resize(n_vocab);

    float eos_p = 0;
    int n_past = 0;

    for (int i = 0; i < n_steps_text_encoder; i++) {
        if (params.progress_callback) {
            const int progress_cur = 100*(i+1)/n_steps_text_encoder;

            params.progress_callback(
                bctx, bark_encoding_step::SEMANTIC, progress_cur, params.progress_callback_user_data);
        }

        if (!bark_eval_encoder_internal(model, allocr, input, logits, &n_past, true, n_threads)) {
            fprintf(stderr, "%s: Could not generate token\n", __func__);
            return false;
        }

        std::vector<float> relevant_logits(logits.begin(), logits.begin() + semantic_vocab_size);
        relevant_logits.push_back(logits[semantic_pad_token]);

        input.clear();

        bark_token next = gpt_sample(
            logits, bctx->rng, temp, &eos_p, &model.t_sample_us, &model.n_sample);

        if (next == semantic_vocab_size || eos_p >= min_eos_p) {
            break;
        }

        input.push_back(next);
        output.push_back(next);
    }

    bctx->semantic_tokens = output;
    bctx->stats.n_sample_semantic = model.n_sample;

    return true;