1
2

git clone https://github.com/ggerganov/llama.cpp.git
cd llama.cpp

1
2
3

mkdir build && cd build
cmake ..
cmake --build . --config Release -j 8

1
2
3

mkdir build && cd build
cmake .. -DGGML_CUDA=ON
cmake --build . --config Release -j 8

1
2
3

mkdir build && cd build
cmake .. -DGGML_METAL=ON
cmake --build . --config Release -j 8

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

#include "llama.h"
#include <iostream>
#include <vector>
#include <string>
#include <stdexcept>

// 错误处理宏
#define LLAMA_ASSERT(x) \
    do { \
        if (!(x)) { \
            std::cerr << "Assertion failed: " << #x << std::endl; \
            std::terminate(); \
        } \
    } while (0)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

int main(int argc, char ** argv) {
    if (argc < 2) {
        std::cerr << "Usage: " << argv[0] << " <model.gguf>" << std::endl;
        return 1;
    }
    std::string model_path = argv[1];

    // 1. 初始化后端（配置 CPU/GPU 等环境）
    llama_backend_init();

    // 2. 获取模型参数的默认设置
    llama_model_params model_params = llama_model_default_params();
    model_params.n_gpu_layers = 35; // 卸载到 GPU 的层数

    // 3. 加载模型
    llama_model * model = llama_load_model_from_file(model_path.c_str(), model_params);
    if (model == nullptr) {
        std::cerr << "Failed to load model" << std::endl;
        return 1;
    }

    // 4. 设置上下文参数
    llama_context_params ctx_params = llama_context_default_params();
    ctx_params.n_ctx = 2048; // 最大上下文大小 (Token数)
    ctx_params.n_threads = 8; // 推理使用的 CPU 线程数

    // 5. 创建上下文
    llama_context * ctx = llama_new_context_with_model(model, ctx_params);
    if (ctx == nullptr) {
        std::cerr << "Failed to create context" << std::endl;
        llama_free_model(model);
        return 1;
    }

    std::cout << "Model and context loaded successfully!" << std::endl;
    // ... 后续处理

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

    std::string prompt = "Q: 日本的首都是哪里？\nA:";
    std::vector<llama_token> tokens_list;
    tokens_list.resize(prompt.length() + 4); // 预留余量的缓冲区大小

    // 是否在开头添加特殊 Token（如 BOS: Begin of Sequence 等）
    bool add_special = true; 
    // 将字符串转换为 Token ID 数组
    int n_tokens = llama_tokenize(
        model, 
        prompt.c_str(), 
        prompt.length(), 
        tokens_list.data(), 
        tokens_list.size(), 
        add_special, 
        false // parse_special
    );

    if (n_tokens < 0) {
        // 缓冲区不足时需要重新分配并重试（为简化省略）
        std::cerr << "Failed to tokenize prompt" << std::endl;
        return 1;
    }
    tokens_list.resize(n_tokens);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

    // 要生成的最大 Token 数
    const int max_gen_tokens = 100;
    
    // 初始化用于批处理评估的结构体
    llama_batch batch = llama_batch_init(512, 0, 1);

    // 将提示词的 Token 添加到批次中
    for (size_t i = 0; i < tokens_list.size(); i++) {
        llama_batch_add(batch, tokens_list[i], i, { 0 }, false);
    }
    // 设置为仅在提示词的最后一个 Token 处输出 Logit（预测结果）
    batch.logits[batch.n_tokens - 1] = true;

    // 首次评估（将提示词送入模型）
    if (llama_decode(ctx, batch) != 0) {
        std::cerr << "llama_decode() failed" << std::endl;
        return 1;
    }

    int n_cur = batch.n_tokens; // 当前上下文长度
    int n_decode = 0;

    std::cout << "\nOutput: ";

    // 初始化采样器上下文（设置 Temperature, Top-K, Top-P 等）
    llama_sampler * smpl = llama_sampler_chain_init(llama_sampler_chain_default_params());
    llama_sampler_chain_add_top_k(smpl, 40);
    llama_sampler_chain_add_top_p(smpl, 0.9f, 1);
    llama_sampler_chain_add_temp(smpl, 0.7f);
    llama_sampler_chain_add_dist(smpl, 1234); // 随机种子

    while (n_decode < max_gen_tokens) {
        // 1. 采样：根据当前上下文预测下一个 Token
        llama_token new_token_id = llama_sampler_sample(smpl, ctx, -1);

        // 2. 如果 Token 是 EOS (End of Sequence)，则结束循环
        if (llama_token_is_eog(model, new_token_id)) {
            break;
        }

        // 3. 将 Token 解码为字符串（文本）并显示
        char buf[128];
        int n_chars = llama_token_to_piece(model, new_token_id, buf, sizeof(buf), 0, false);
        if (n_chars > 0) {
            std::cout << std::string(buf, n_chars) << std::flush;
        }

        // 4. 将新生成的 Token 作为下一个批次准备就绪
        llama_batch_clear(batch);
        llama_batch_add(batch, new_token_id, n_cur, { 0 }, true);

        // 5. 模型评估（更新 KV 缓存，预测下一个 Token）
        if (llama_decode(ctx, batch) != 0) {
            std::cerr << "Failed to evaluate" << std::endl;
            break;
        }

        n_cur += 1;
        n_decode += 1;
    }

    std::cout << std::endl;

    // 清理资源
    llama_sampler_free(smpl);
    llama_batch_free(batch);
    llama_free(ctx);
    llama_free_model(model);
    llama_backend_free();

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// 推理刚刚结束，在进行采样前获取原始的 logit 数组
float * logits = llama_get_logits_ith(ctx, batch.n_tokens - 1);
int n_vocab = llama_n_vocab(model);

// 违禁 Token 的 ID 列表（例如 1234, 5678）
std::vector<llama_token> forbidden_tokens = { 1234, 5678 };

// 将违禁 Token 的出现概率降为 0（将 Logit 设置为负无穷大）
for (llama_token bad_tok : forbidden_tokens) {
    logits[bad_tok] = -INFINITY;
}