KBaba7/llama.cpp

1#include "arg.h"2#include "common.h"3#include "log.h"4#include "llama.h"5 6#include <cmath>7#include <cstdio>8#include <string>9#include <vector>10 11static void print_usage(int, char ** argv) {12    LOG("\nexample usage:\n");13    LOG("\n    %s -m model.gguf --junk 250 --pos 90 --keep 32 --grp-attn-n 2 [--seed 1234]\n", argv[0]);14    LOG("\n");15}16 17int main(int argc, char ** argv) {18    common_params params;19 20    params.n_junk = 250;21    params.n_keep = 32;22    params.i_pos  = -1;23 24    if (!common_params_parse(argc, argv, params, LLAMA_EXAMPLE_PASSKEY, print_usage)) {25        return 1;26    }27 28    common_init();29 30    int n_junk = params.n_junk;31    int n_keep = params.n_keep;32    int n_grp  = params.grp_attn_n;33    int i_pos  = params.i_pos;34 35    if (i_pos == -1) {36        i_pos = rand() % n_junk;37    }38 39    const std::string prompt_prefix = "There is an important info hidden inside a lot of irrelevant text. Find it and memorize them. I will quiz you about the important information there.";40    const std::string prompt_suffix = " What is the pass key? The pass key is";41 42    // generate junk text43    params.prompt = prompt_prefix;44 45    const int passkey = rand() % 50000 + 1;46 47    for (int i = 0; i < n_junk; i++) {48        if (i % n_junk == i_pos) {49            params.prompt += " The pass key is " + std::to_string(passkey) + ". Remember it. " + std::to_string(passkey) + " is the pass key.";50        }51 52        params.prompt += " The grass is green. The sky is blue. The sun is yellow. Here we go. There and back again.";53    }54 55    params.prompt += prompt_suffix;56 57    // init LLM58 59    llama_backend_init();60    llama_numa_init(params.numa);61 62    // initialize the model63 64    llama_model_params model_params = common_model_params_to_llama(params);65 66    llama_model * model = llama_model_load_from_file(params.model.c_str(), model_params);67 68    if (model == NULL) {69        LOG_ERR("%s: unable to load model\n" , __func__);70        return 1;71    }72 73    const llama_vocab * vocab = llama_model_get_vocab(model);74 75    // initialize the context76 77    llama_context_params ctx_params = common_context_params_to_llama(params);78 79    ctx_params.n_ctx = llama_model_n_ctx_train(model)*n_grp + n_keep;80 81    GGML_ASSERT(ctx_params.n_batch % n_grp == 0 && "n_batch must be divisible by n_grp");82 83    llama_context * ctx = llama_init_from_model(model, ctx_params);84    if (ctx == NULL) {85        LOG_ERR("%s: failed to create the llama_context\n" , __func__);86        return 1;87    }88 89    auto sparams = llama_sampler_chain_default_params();90 91    llama_sampler * smpl = llama_sampler_chain_init(sparams);92 93    llama_sampler_chain_add(smpl, llama_sampler_init_greedy());94 95    // tokenize the prompt96    std::vector<llama_token> tokens_list;97    tokens_list = common_tokenize(ctx, params.prompt, true);98 99    // tokenize the prefix and use it as a sink100    const int n_tokens_prefix = common_tokenize(ctx, prompt_prefix, true).size();101 102    const int n_tokens_all = tokens_list.size();103 104    // we leave a margin of 16 tokens for the generated text - it should contain just the passkey105    const int n_predict = 16;106 107    // total length of the sequences including the prompt108    const int n_len = n_tokens_all + n_predict;109 110    const int n_ctx       = llama_n_ctx(ctx) - n_keep;111    const int n_kv_req    = llama_n_ctx(ctx);112    const int n_batch     = ctx_params.n_batch;113    const int n_batch_grp = ctx_params.n_batch/n_grp;114 115    LOG_INF("\n%s: n_len = %d, n_ctx = %d, n_kv_req = %d, n_grp = %d, n_batch = %d, n_junk = %d, i_pos = %d\n", __func__, n_len, n_ctx, n_kv_req, n_grp, n_batch, n_junk, i_pos);116 117    // print the prompt token-by-token118 119    LOG_INF("\n");120    LOG_INF("prefix tokens: %d\n", n_tokens_prefix);121    LOG_INF("prompt tokens: %d\n", n_tokens_all);122    //LOG_INF("prompt: %s\n", params.prompt.c_str());123 124    llama_batch batch = llama_batch_init(params.n_batch, 0, 1);125 126    int n_past = 0;127 128    // fill the KV cache129    for (int i = 0; i < n_ctx; i += n_batch) {130        if (i > 0 && n_grp > 1) {131            // if SelfExtend is enabled, we compress the position from the last batch by a factor of n_grp132            const int ib = i/n_batch - 1;133            const int bd = n_batch_grp*(n_grp - 1);134 135            llama_kv_cache_seq_add (ctx, 0, n_past - n_batch,         n_past,         ib*bd);136            llama_kv_cache_seq_div (ctx, 0, n_past - n_batch + ib*bd, n_past + ib*bd, n_grp);137            llama_kv_cache_update  (ctx);138 139            n_past = llama_kv_cache_seq_pos_max(ctx, 0) + 1;140        }141 142        common_batch_clear(batch);143 144        for (int j = 0; j < n_batch && i + j < n_tokens_all; j++) {145            common_batch_add(batch, tokens_list[i + j], n_past++, { 0 }, false);146        }147 148        if (i + n_batch >= n_tokens_all) {149            batch.logits[batch.n_tokens - 1] = true;150        }151 152        if (llama_decode(ctx, batch) != 0) {153            LOG_INF("%s: llama_decode() failed\n", __func__);154            return 1;155        }156 157        LOG_INF("%s: processed: [%6d, %6d)\n", __func__, i, std::min(i + n_batch, n_tokens_all));158 159        if (i + n_batch >= n_tokens_all) {160            break;161        }162    }163 164    for (int i = n_ctx; i < n_tokens_all; i += n_batch) {165        const int n_discard = n_batch;166 167        LOG_INF("%s: shifting KV cache with %d\n", __func__, n_discard);168 169        llama_kv_cache_seq_rm (ctx, 0, n_keep            , n_keep + n_discard);170        llama_kv_cache_seq_add(ctx, 0, n_keep + n_discard, n_ctx,  -n_discard);171      //llama_kv_cache_defrag (ctx);172        llama_kv_cache_update (ctx);173 174        n_past = llama_kv_cache_seq_pos_max(ctx, 0) + 1;175 176        common_batch_clear(batch);177 178        for (int j = 0; j < n_batch && i + j < n_tokens_all; j++) {179            common_batch_add(batch, tokens_list[i + j], n_past++, { 0 }, false);180        }181 182        if (i + n_batch >= n_tokens_all) {183            batch.logits[batch.n_tokens - 1] = true;184        }185 186        if (llama_decode(ctx, batch) != 0) {187            LOG_ERR("%s: llama_decode() failed\n", __func__);188            return 1;189        }190 191        LOG_INF("%s: processed: [%6d, %6d)\n", __func__, i, std::min(i + n_batch, n_tokens_all));192    }193 194    {195        const int n_discard = n_past - n_ctx + n_predict;196 197        if (n_discard > 0) {198            LOG_INF("%s: shifting KV cache with %d to free space for the answer\n", __func__, n_discard);199 200            llama_kv_cache_seq_rm (ctx, 0, n_keep            , n_keep + n_discard);201            llama_kv_cache_seq_add(ctx, 0, n_keep + n_discard, n_ctx,  -n_discard);202          //llama_kv_cache_defrag (ctx);203            llama_kv_cache_update (ctx);204 205            n_past = llama_kv_cache_seq_pos_max(ctx, 0) + 1;206        }207    }208 209    LOG_INF("\n");210    LOG_INF("%s: passkey = %d, inserted at position %d / %d (token pos: ~%d)\n", __func__, passkey, i_pos, n_junk, (i_pos * n_tokens_all) / n_junk);211    LOG_INF("\n");212 213    // main loop214 215    int n_cur    = n_tokens_all;216    int n_decode = 0;217 218    LOG_INF("%s", prompt_suffix.c_str());219 220    const auto t_main_start = ggml_time_us();221 222    while (n_cur <= n_len) {223        // sample the next token224        {225            const llama_token new_token_id = llama_sampler_sample(smpl, ctx, batch.n_tokens - 1);226 227            // is it an end of generation?228            if (llama_vocab_is_eog(vocab, new_token_id) || n_cur == n_len) {229                LOG("\n");230 231                break;232            }233 234            LOG("%s", common_token_to_piece(ctx, new_token_id).c_str());235 236            n_decode += 1;237 238            // prepare the next batch239            common_batch_clear(batch);240 241            // push this new token for next evaluation242            common_batch_add(batch, new_token_id, n_past++, { 0 }, true);243        }244 245        n_cur += 1;246 247        // evaluate the current batch with the transformer model248        if (llama_decode(ctx, batch)) {249            LOG_ERR("%s : failed to eval, return code %d\n", __func__, 1);250            return 1;251        }252    }253 254    LOG("\n");255 256    const auto t_main_end = ggml_time_us();257 258    LOG_INF("%s: decoded %d tokens in %.2f s, speed: %.2f t/s\n",259            __func__, n_decode, (t_main_end - t_main_start) / 1000000.0f, n_decode / ((t_main_end - t_main_start) / 1000000.0f));260 261    LOG("\n");262    llama_perf_context_print(ctx);263 264    LOG("\n");265 266    llama_sampler_free(smpl);267 268    llama_batch_free(batch);269 270    llama_free(ctx);271    llama_model_free(model);272 273    llama_backend_free();274 275    return 0;276}277