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; // 最大コンテキストサイズ (トークン数)
    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); // 余裕を持たせたバッファサイズ

    // 特殊トークン（BOS: Begin of Sequence 等）を先頭に追加するかどうか
    bool add_special = true; 
    // 文字列をトークン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

    // 生成する最大トークン数
    const int max_gen_tokens = 100;
    
    // バッチ評価のための構造体を初期化
    llama_batch batch = llama_batch_init(512, 0, 1);

    // プロンプトのトークンをバッチに追加
    for (size_t i = 0; i < tokens_list.size(); i++) {
        llama_batch_add(batch, tokens_list[i], i, { 0 }, false);
    }
    // プロンプトの最後のトークンでのみロジット（予測結果）を出力するように設定
    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. サンプリング：現在のコンテキストに基づいて次のトークンを予測
        llama_token new_token_id = llama_sampler_sample(smpl, ctx, -1);

        // 2. トークンが EOS (End of Sequence) ならループ終了
        if (llama_token_is_eog(model, new_token_id)) {
            break;
        }

        // 3. トークンを文字列（テキスト）にデコードして表示
        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. 新しく生成されたトークンを次のバッチとして準備
        llama_batch_clear(batch);
        llama_batch_add(batch, new_token_id, n_cur, { 0 }, true);

        // 5. モデルの評価（KVキャッシュを更新し、次を予測）
        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

// 推論直後、サンプリングを行う前に生のロジット配列を取得
float * logits = llama_get_logits_ith(ctx, batch.n_tokens - 1);
int n_vocab = llama_n_vocab(model);

// 禁止トークンのIDリスト（例として 1234, 5678）
std::vector<llama_token> forbidden_tokens = { 1234, 5678 };

// 禁止トークンの出現確率を 0 (Logitをマイナス無限大) にする
for (llama_token bad_tok : forbidden_tokens) {
    logits[bad_tok] = -INFINITY;
}