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;
}