LLM on kenji.blog

llama.cpp 使用方法與 C++ 客製化入門

Fri, 11 Sep 2026 11:00:00 +0900

近年來，大型語言模型 (LLM) 的進化非常驚人，其應用範圍每天都在擴大。然而，要在本機環境中運行具有數十億、數百億參數的模型，通常需要配備龐大 VRAM 的高階 GPU。打破這種「硬體壁壘」，並在一般 PC、Mac 甚至 Raspberry Pi 等設備上實現 LLM 實用推理的，正是 llama.cpp。

本文不僅介紹單純的命令列工具用法，還將針對工程師進行極為詳細的解說，內容涵蓋其基礎技術 ggml 的架構、Transformer 和量化的數學背景，以及如何利用 C++ API 將 LLM 嵌入到獨立應用程式中並進行客製化。

1. llama.cpp 與 ggml 概要

llama.cpp 是由 Georgi Gerganov 開發，使用 C/C++ 編寫的輕量級 LLM 推理引擎。它最初是為了在 Apple Silicon (M1/M2 Mac) 上高速運行 Meta 的 LLaMA 模型而誕生的，但現在已經支援各種架構和模型。

它最大的特點是無外部依賴的純 C/C++ 實作。它不需要 Python 或 PyTorch 等龐大的生態系統，可以編譯為單一執行檔，因此部署非常容易。

這個 llama.cpp 的核心是張量運算函式庫 ggml。ggml 是從零開始設計的，旨在將 CPU（以及部分 GPU）上的機器學習矩陣運算優化到極致。

1.1 為什麼 llama.cpp 這麼快？

活用記憶體映射 (mmap)：在將模型權重載入記憶體時，透過利用作業系統的 mmap，可以避免全部載入 RAM，從而實現快速啟動和節省記憶體。
徹底優化 SIMD 指令：它利用了 AVX2、AVX-512、ARM NEON、Apple AMX 等 CPU 特有的指令集，實現了矩陣乘法的超高速化。
量化 (Quantization)：將 16-bit 浮點數 (FP16) 的權重壓縮為 4-bit、5-bit、8-bit 的整數，從而消除記憶體頻寬的瓶頸（詳情後述）。

2. 數學背景：Transformer 與量化 (Quantization)

為了深入理解 llama.cpp，我們需要了解它所計算的數學公式，以及它是如何對計算進行近似的。

2.1 Transformer 的推理過程

LLaMA 等模型採用了自迴歸型 (Auto-regressive) 的 Transformer 解碼器架構。文字生成的核心是 Self-Attention (自我注意力) 機制。

對於作為輸入的隱藏狀態矩陣 $X \in \mathbb{R}^{N \times d}$，查詢 $Q$、鍵 $K$、值 $V$ 都是透過與權重矩陣的乘積來計算的。

$$ Q = X W_Q, \quad K = X W_K, \quad V = X W_V $$

在此，Attention 的輸出定義如下：

$$ \text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V $$

在 llama.cpp 的推理迴圈中，瓶頸在於這些巨大的矩陣 $W_Q, W_K, W_V$ 或前饋神經網路 (FFN) 的權重矩陣與向量 $X$（在生成階段由於每次處理一個 Token，因此 $N=1$）的乘積，也就是 GEMV (General Matrix-Vector Multiplication)。

2.2 量化 (Quantization) 的數學基礎

在記憶體存取頻寬成為瓶頸的推理中，使用較小的位元數來表示權重參數的量化是不可或缺的。在此說明 llama.cpp 中廣泛使用的區塊單位量化（例如 Q4_K 或 Q4_0）的基本原理。

舉例來說，考慮 FP16 權重矩陣 $W$ 的一部分，長度為 $B$（通常為 32 或 64）的區塊 $w = [w_1, w_2, \dots, w_B]$。我們將此區塊近似為 4-bit 整數 $q_i \in [-8, 7]$ 和單一的縮放因子 $\Delta$（FP16 或 FP32）。

$$ w_i \approx \Delta \times q_i $$

$\Delta$ 是根據區塊內的最大絕對值決定的。

$$ \Delta = \frac{\max_i |w_i|}{7} $$

當使用量化後的權重計算內積 $y = w \cdot x$ 時，如果將輸入向量 $x$ 也同樣量化為 $x_i \approx \Delta_x \times q_{x, i}$，則：

$$ y = \sum_{i=1}^{B} w_i x_i \approx \Delta \Delta_x \sum_{i=1}^{B} q_i q_{x, i} $$

這個 $\sum q_i q_{x, i}$ 的部分變成了純整數運算，可以使用 SIMD 指令進行極為高速的平行計算。這就是 llama.cpp 能在 CPU 上達到驚人速度的數學機關。

3. 架構與推理流程

為了理解 llama.cpp 的內部運作，我們使用以下的 Mermaid 圖表來展示整體系統的架構和資料流向。

graph TD A["使用者輸入 (字串)"] --> B["llama.cpp Tokenizer"] B --> C["Token ID (int32 陣列)"] C --> D["上下文緩衝區 (KV Cache)"] D --> E["ggml 計算圖"] E --> F["Transformer 層"] subgraph "ggml 引擎" F --> G["Self-Attention (RoPE)"] G --> H["前饋神經網路"] H --> F end F --> I["Logits (詞彙表大小)"] I --> J["採樣器 (Temperature, Top-K, Top-P)"] J --> K["選定的 Token ID"] K --> L["llama.cpp Detokenizer"] L --> M["輸出字串"] K -. "自迴歸迴圈" .-> D

文字生成是一個自迴歸迴圈，每輸出一個 Token，它就會作為下一個輸入被加入到 KV Cache 中，然後再次通過計算圖。

4. 環境建置與編譯方法

在將 llama.cpp 嵌入到 C++ 專案之前，讓我們先嘗試編譯其原始碼。

4.1 複製儲存庫

1
2


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

4.2 使用 CMake 進行編譯

當作為 C++ 專案嵌入到其他應用程式時，使用 CMake 是最標準的做法。透過啟用各個平台的加速器（後端），可以加快計算速度。

僅 CPU（基本編譯）：

1
2
3


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

使用 NVIDIA GPU (CUDA) 時：

1
2
3


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

使用 Apple Silicon (Metal) 時：

1
2
3


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

編譯成功後，會在 build/bin/ 目錄下產生 llama-cli 等執行檔，以及用於後述 C++ API 連結的 llama 函式庫（和 ggml 函式庫）。

5. C++ 客製化入門：llama.cpp API 的使用

從這裡開始將解說本文的重點：如何透過 C++ 程式碼控制 llama.cpp。如果不僅僅是使用命令列工具，而是要將 LLM 嵌入到自己的應用程式（例如遊戲引擎、桌面應用程式、嵌入式系統等），就必須直接呼叫 C++ API。

llama.cpp 主要透過名為 llama.h 的標頭檔提供 C 語言介面。從 C++ 呼叫時同樣使用此介面。

5.1 必要最少的 Include 與設定

在自己的專案中使用 llama.cpp 時，請 Include 以下內容。

 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)

5.2 載入模型與初始化上下文

首先，載入 .gguf 格式的模型檔案，並分配用於推理的上下文（記憶體空間和 KV Cache）。

 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;
 // ... 後續的處理

5.3 提示詞的 Token 化 (Tokenization)

LLM 並不是直接理解文字，而是將其作為整數 ID（Token）的序列來處理。因此需要將輸入字串轉換為 Token。

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

5.4 推理迴圈與採樣

將 Token 輸入到模型中，獲取下一個 Token 的機率分佈 (Logits)，然後從中進行採樣以決定下一個 Token，如此建構一個迴圈。

 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 Cache 並預測下一個）
 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;
}

這段程式碼使用 llama.cpp 的基本 API 實作了自訂的推理迴圈。它使用 llama_batch 結構體來管理 Token 群，並透過 llama_decode 執行神經網路的前向傳播 (Forward Pass)。

6. 進階客製化案例：透過 C++ 進行 Logit 操作與懲罰控制

如果不只是單純的文字生成，而是強制輸出特定格式（例如僅限 JSON），或是控制不輸出特定的禁止詞彙時，我們可以在 C++ 端直接操作採樣前的 Logit (Logits)。

可以獲取模型在輸出每個 Token 之前，原始分數（轉換為機率前的值）的陣列。

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

如此一來，透過直接處理 C++ API，我們就能實現透過 LangChain 或 Python 難以做到或開銷過大的**「在每個推理週期進行微秒級的介入」**。

7. 效能調校的秘訣

在完成 C++ 實作後，這裡介紹幾個為了實際應用而將速度提升至極限的檢查點。

批次處理的優化： 當同時處理來自多個使用者的請求時，可以在 llama_batch 中包含多個序列，並一次呼叫 llama_decode（Continuous Batching）。這能讓記憶體存取共用，從而大幅提升吞吐量。
啟用 Flash Attention： 透過在上下文參數中設定 ctx_params.flash_attn = true;，可以在減少記憶體使用量的同時加快 Attention 計算。在處理長上下文（數萬個 Token）時，這是必須的設定。
NUMA 支援： 在多插槽的伺服器環境中，在 llama_backend_init() 之前正確設定 NUMA，可以減少記憶體存取的延遲。

8. 結語

本文從 llama.cpp 的數學背景開始，詳細解說了其架構，以及如何活用 C++ API 來建構自訂的推理引擎。

雖然 Python 的生態系統在製作原型時非常方便，但在部署到邊緣裝置、嵌入到遊戲或要求即時處理的正式環境中，基於 C/C++ 的 llama.cpp 的直接控制展現了壓倒性的優勢。

大家也務必親自動手編寫 C++ 程式碼，體驗在本機環境中自由操控 LLM 的樂趣。

參考連結集

llama.cpp Official Repository

ggml - Tensor Library

Attention Is All You Need (Vaswani et al., 2017)

【2026年最新】在Windows環境下運行本地LLM的完全指南

Fri, 11 Sep 2026 10:00:00 +0900

1. 簡介：為什麼現在要在 Windows 上運行本地 LLM？

2026年的今天，生成式 AI 與大型語言模型（LLM）的進化，展現出從雲端上巨大的 API 服務，轉向在個人 PC 與地端環境運作的「本地 LLM」的巨大典範轉移。雖然 OpenAI 的 GPT-5 與 Anthropic 的 Claude 3.5 等雲端 AI 非常強大，但企業與個人並不能將所有數據都傳送到雲端。從隱私、安全性、延遲，以及長期、可持續性成本的觀點來看，對本地 LLM 的需求正迎來前所未有的爆發性增長。

尤其在 Windows 環境下，本地 LLM 生態系統的進化更是令人矚目。幾年前，「說到 AI 開發與執行就是 Linux」還是常識，但到了 2026 年的今天，Windows 已經蛻變成一個非常強大且易於使用的 AI 平台。

本文將基於 2026 年最新的技術趨勢，為您提供在 Windows 環境下建置、營運與最佳化本地 LLM 的完全指南。從適合初學者的 Ollama 簡易建置，到適合進階使用者的 llama.cpp 極限最佳化，再到 VRAM 計算的數學方法、架構的深入理解，以及本地的微調（Fine-tuning），將以壓倒性的豐富內容為您進行徹底解說。

1.1 2026 年本地 LLM 的相關技術趨勢

塑造當前本地 LLM 生態系統的主要趨勢如下：

GGUF 格式的全面普及：將元數據（Metadata）與張量（Tensor）整合到單一檔案的 GGUF（GPT-Generated Unified Format）已經完全成為業界標準（De facto standard）。這使得使用者只需從 Hugging Face 下載一個檔案，就能在任何環境下執行。
MoE（Mixture of Experts）架構的民主化：市面上發布了許多小規模卻高效能的 MoE 模型，透過在推論時僅啟動部分專家網路（Expert），在降低消費級 PC 運算負載的同時，展現出足以媲美巨大模型的效能。
推論引擎的高度抽象化與最佳化：Ollama、LM Studio、AnythingLLM 等工具變得更加完善，使用者不再需要擔心安裝 CUDA 驅動程式等複雜的依賴關係。此外，隨著 FlashAttention 3 對 Windows 提供原生支援，推論速度也獲得了戲劇性的提升。
NPU 的應用與 Windows Copilot+ PC 的崛起：即使是沒有配備 GPU 的筆記型電腦，利用內建的 NPU（神經網絡處理單元）以低功耗運行小型 LLM（SLM: Small Language Models）的技術也已進入實用階段。

2. 硬體需求與作業系統準備

為了讓本地 LLM 能以實用的速度（每秒 15 到 30 個 Token 以上）運行，硬體的選擇是最為重要的。

2.1 建議硬體配置

隨著 AI PC 的進化，硬體規格的要求也隨之改變。

作業系統 (OS)：Windows 11 Pro (24H2 或更高版本)。為了使用 WSL2 的完整功能、進階記憶體管理，以及 DirectML 的最新 API，這是必備的。
處理器 (CPU)：Intel Core Ultra 200 系列或更高版本，或 AMD Ryzen 9000 系列或更高版本。若要同時使用 CPU 進行推論，高頻寬記憶體通訊是不可或缺的。
記憶體 (RAM)：最低 32GB，建議 64GB 以上。主記憶體的頻寬（MB/s）在 CPU 推論或卸載（Offload）時會成為決定性的瓶頸。DDR5-6000 以上的高速記憶體是最理想的。
顯示卡 (GPU)：NVIDIA RTX 4000 / 5000 系列。對於本地 LLM 來說，最重要的不是運算效能，而是「VRAM（顯示記憶體）容量」。
- 入門級：RTX 4060 Ti (16GB 版) - CP值最高。非常適合 8B 到 14B 等級的模型。
- 中階：RTX 4070 Ti SUPER (16GB) / RTX 4080 SUPER (16GB)
- 高階：RTX 4090 (24GB) / RTX 5090 (32GB) - 要運行 30B 到 70B 等級的量化模型會需要用到。
儲存空間：PCIe Gen4 或 Gen5 的 NVMe SSD。能大幅縮短載入數十 GB 模型所需的時間。

2.2 WSL2 (Windows Subsystem for Linux 2) 設定

雖然許多 GUI 工具能在 Windows 原生環境下運行，但對於使用 Python 進行開發、編譯最新工具，以及後續會提到的 LoRA 微調來說，WSL2 會非常方便。在 Windows 11 的最新環境中，只需在主機端安裝 NVIDIA 驅動程式，即可在 WSL2 中透通地使用 GPU (CUDA)。

以系統管理員身分開啟 PowerShell，並執行以下命令：

1
2
3
4
5


# 安裝 WSL2 與最新的 Ubuntu
wsl --install -d Ubuntu-24.04

# 更新核心
wsl --update

安裝完成後，在 WSL2 終端機內執行 nvidia-smi，如果能正常辨識到 GPU，即代表成功。

3. 本地 LLM 的架構與推論機制

了解模型在本地環境中是如何生成文字的內部結構，對於疑難排解和效能最佳化非常有用。

以下的 Mermaid 圖表展示了典型的本地 LLM 推論流程。

graph TD User["使用者輸入 (提示詞)"] --> Tokenizer["分詞器 (Tokenizer)"] Tokenizer --> Embedding["嵌入層 (Embedding)"] subgraph "Transformer Block (x Layers)" Embedding --> Attn["自注意力機制 (Self-Attention)"] Attn --> KVCache["KV 快取 (保存 Key/Value)"] Attn --> FFN["前饋神經網絡 (FFN)"] end FFN --> Logits["Logits 計算 (Logits)"] Logits --> Sampler["取樣器 (Temperature, Top-K, Top-P)"] Sampler --> OutputToken["輸出 Token"] OutputToken --> |"自迴歸生成"| Tokenizer OutputToken --> Decoder["反分詞器 (Detokenizer)"] Decoder --> FinalOutput["最終輸出文字"]

3.1 兩個階段：Prefill 與 Decode

LLM 的文字生成分為兩個具有不同計算特性的階段。

Prefill（提示詞處理）階段：將輸入的完整提示詞一次性處理並進行理解的階段。由於可以平行計算，GPU 的運算能力（FLOPS）將直接影響速度。如果提示詞很長，這個階段可能會需要花費數秒鐘的時間。
Decode（Token 生成）階段：逐一預測 Token 並將其作為下一次輸入（自迴歸）的階段。因為在這個階段平行計算會受到限制，所以 GPU 的 VRAM 頻寬（Memory Bandwidth）會成為決定性的瓶頸。

4. VRAM 消耗量的計算與模型大小的數學解析

為了正確判斷「自己的 PC 能運行什麼模型？」，我們必須了解 VRAM 的計算公式。若因 VRAM 不足而觸發回退到系統記憶體（RAM）的機制，推論速度將會變慢 10 到 100 倍。

4.1 基於參數大小的基礎 VRAM

這代表將模型的權重載入到 VRAM 所需的記憶體容量。可透過模型大小 $P$（參數數量，單位：10億 = 1B）與每個參數所佔的位元組數 $B$ 來進行計算。

$$ V_{base} = P \times B \quad \text{(GB)} $$

例如，如果以 FP16（半精度浮點數，16位元=2位元組）載入一個 8B（80億）參數的模型：

$$ V_{base} = 8 \times 2 = 16 \text{ GB} $$

也就是說，即使 GPU 擁有 16GB 的 VRAM，光是載入模型就會幾乎達到極限。

4.2 量化 (Quantization) 的魔法

這時「量化」就派上用場了。透過降低參數的精度，可以大幅縮減模型大小。以最常見的 4bit 量化（例：Q4_K_M）來說，每個參數平均大約僅佔 0.55 個位元組。

$$ V_{base\_4bit} = 8 \times 0.55 = 4.4 \text{ GB} $$

因此，只要有 16GB 的 VRAM，就能綽綽有餘地運行 8B 模型。

4.3 KV 快取計算 (GQA 支援版)

在進行推論時，用來保留過去上下文的「KV 快取」會消耗 VRAM。在如 Llama 3 等最新模型中，為了節省記憶體，採用了 GQA（Grouped Query Attention）技術。

KV 快取的消耗量 $V_{kv}$（GB）可以用以下的數學公式來表示：

$$ V_{kv} = 2 \times b \times s \times l \times \left( \frac{h_{kv}}{h_q} \right) \times h_q \times d \times B_{kv} \div 10^9 $$

整理後，可以使用 Key 和 Value 的注意力頭數量 $h_{kv}$ 進行更簡單的計算：

$$ V_{kv} = 2 \times b \times s \times l \times h_{kv} \times d \times B_{kv} \div 10^9 $$

這裡的變數代表：

$b$：批次大小（個人本地使用時通常為 1）
$s$：序列長度（上下文長度，例：8192）
$l$：層數（例：32）
$h_{kv}$：KV 注意力頭數（例：8）
$d$：每個注意力頭的維度（例：128）
$B_{kv}$：KV 快取的位元組數（FP16 為 2）

計算範例（Llama 3 8B, 上下文 8192, FP16 快取）： $V_{kv} = 2 \times 1 \times 8192 \times 32 \times 8 \times 128 \times 2 \div 10^9 \approx 1.07 \text{ GB}$

請注意，隨著上下文長度 $s$ 的增加，所需的 VRAM 將呈現線性增長。

5. 實踐 1：使用 Ollama 進行最快、最短的環境建置

理解了理論之後，讓我們實際在 Windows 環境中運行 LLM 看看。在 2026 年的今天，最對使用者友善的工具非「Ollama」莫屬。它提供了類似 Docker 般直覺的 CLI（命令列介面）。

5.1 安裝與執行

從 Ollama 官方網站下載並執行 Windows 版安裝程式。
開啟 PowerShell，並輸入以下命令。在這裡，我們使用支援日文的 llama3:8b。

1

ollama run llama3:8b

第一次執行時會下載模型。下載完成後，就可以直接在終端機中進行對話。

5.2 使用 Modelfile 建立客製化 AI

您可以輕鬆建立具有特定人格特質（Persona）的 AI。請在任意位置建立一個名為 Modelfile 的檔案。

1
2
3
4
5
6
7
8
9


FROM llama3:8b

SYSTEM """
你是一位非常優秀的資深軟體工程師。
對於使用者的提問，請務必搭配程式碼範例，以合乎邏輯且簡潔的方式進行回答。
"""

PARAMETER temperature 0.3
PARAMETER num_ctx 8192

使用以下命令來建置並執行您專屬的模型：

1
2


ollama create SeniorDev -f ./Modelfile
ollama run SeniorDev

5.3 透過外部應用程式 (AI 編輯器) 存取

Ollama 會在 http://localhost:11434 開放一個與 OpenAI 相容的 API 端點（Endpoint）。只需在 Cursor 或 Continue.dev 等 VS Code 擴充套件的後端設定中，將 URL 指定為上述位置，並將模型名稱指定為 SeniorDev 等，就能免費實現強大的本地程式碼助手。

6. 實踐 2：使用 llama.cpp 進行極限效能調校

如果您想要更精細的記憶體管理，或是想搶先嘗試最新格式（例如 EXL2 或 IQ 量化等），可以直接操作核心引擎 llama.cpp。

6.1 llama.cpp 的編譯步驟

在 Windows 環境下，最好的做法是使用 CUDA Toolkit 與 CMake 從原始碼進行編譯。

1
2
3
4
5
6
7
8


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

# 設定為支援 CUDA 並進行編譯
cmake .. -DLLAMA_CUBLAS=ON -DBUILD_SHARED_LIBS=OFF
cmake --build . --config Release -j 16

6.2 在伺服器模式下的進階啟動

使用編譯出來的 llama-server.exe 來託管（Host）模型。

1
2
3
4
5
6
7


.\bin\Release\llama-server.exe `
 --model "C:\models\Llama-3-8B-Instruct.Q4_K_M.gguf" `
 --ctx-size 8192 `
 --n-gpu-layers 99 `
 --threads 8 `
 --flash-attn `
 --port 8080

--n-gpu-layers 99：盡可能將所有層都卸載到 GPU VRAM 中。
--flash-attn：啟用 FlashAttention 3，以提升推論速度並減少 KV 快取的 VRAM 消耗。

7. GUI 前端介面：LM Studio 與本地 RAG 建置

如果您對命令列（Command Line）有所抗拒，或者想要更直覺地進行 RAG（檢索增強生成），可以使用 GUI。

7.1 LM Studio

LM Studio 是一款出色的應用程式，它將模型搜尋、下載、系統需求事前檢查，以及聊天 UI 全部整合在一起。只需按下應用程式內的「Local Server」按鈕，就能啟動相容於 OpenAI 的 API。

7.2 使用 AnythingLLM 的 RAG 架構

這是讀取公司內部文件或個人筆記的 RAG 環境架構圖：

graph LR Document["文件 (PDF, MD)"] --> Chunking["區塊分割 (Chunking)"] Chunking --> EmbedModel["嵌入模型 (Embedding Model)"] EmbedModel --> VectorDB["向量資料庫 (Vector DB)"] UserQuery["使用者提問"] --> EmbedQuery["提問的嵌入向量化"] EmbedQuery --> VectorDB VectorDB --> |"相似度搜尋"| RetrievedDocs["擷取相關文件"] UserQuery --> PromptBuilder["生成提示詞 (Prompt)"] RetrievedDocs --> PromptBuilder PromptBuilder --> LocalLLM["本地 LLM"] LocalLLM --> Answer["最終回答"]

只要使用 AnythingLLM 電腦版（Windows），在設定畫面中指定 Ollama（作為 LLM 與 Embedding 引擎），並設定使用本地的 VectorDB（LanceDB），短短幾分鐘內就能完成這個架構。這將誕生一個完全不會向外部傳送任何資料的私有 AI。

8. 在 Windows WSL2 上進行微調 (LoRA)

不僅是在本地運行，如果您還想用自己的資料讓模型變得更聰明，可以使用 LoRA（Low-Rank Adaptation）來進行微調（Fine-tuning）。在 2026 年的今天，只要使用「Unsloth」這個函式庫，在 Windows 的 WSL2 環境下，即使只有 16GB 的 VRAM，也能在數小時內完成 8B 模型的訓練。

在 WSL2 的 Ubuntu 內執行以下命令來建立環境：

1
2
3
4


conda create --name unsloth_env python=3.11
conda activate unsloth_env
pip install "unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git"
pip install --no-deps trl peft accelerate bitsandbytes

Unsloth 將 CUDA 核心優化到了極致，與標準的 Hugging Face 函式庫相比，訓練速度約為兩倍，VRAM 消耗量則減半。只要開啟 Jupyter Notebook 並載入資料集（JSONL 格式），即使是 VRAM 為 12GB 到 16GB 的 RTX 4060 Ti 等顯示卡，也能夠完成幾個 Epoch 的訓練。

9. 效能與疑難排解

以下是常遇到的問題及其解決方案：

1. 推論速度極端緩慢（1～2 tokens/s）

原因：模型無法完全載入到 VRAM 中，導致被卸載（Offload）到系統記憶體（RAM）。 解決方案：請在工作管理員中確認「專用 GPU 記憶體」。如果已經達到極限，請縮小上下文大小（-c），或是使用位元數更低的量化模型（如 Q4_K_M 等）。

2. 「CUDA out of memory」錯誤

原因：VRAM 已經完全耗盡。特別是在對話時間過長，導致 KV 快取過度膨脹時會發生。 解決方案：刻意限制並調小參數值，如果是 Ollama，請調小 num_ctx；如果是 llama.cpp，請調小 -c 的數值。

3. 日文（或其他非英語）的生成很奇怪

原因：提示詞模板（Prompt Template）不一致，或是使用了不支援該語言的模型。 解決方案：請使用模型名稱中包含 Instruct 的版本，並確認工具端是否選擇了模型作者指定的正確模板格式（如 ChatML 或 Llama 3 格式）。

10. 總結與未來展望

在 2026 年，於 Windows 環境下建置本地 LLM 已不再是少部分工程師的特權。隨著 GGUF 格式成為業界標準、Ollama 與 LM Studio 等完善生態系統的出現，以及以 FlashAttention 為首的硬體最佳化，任何人都可以輕易打造出企業級的 AI 環境。

請務必活用本文所解說的以下重點：

使用 VRAM 的數學計算，合乎邏輯地選擇最適合自己 PC 規格的模型大小與量化等級。
使用 Ollama 以最快的速度建置環境，並與 AI 編輯器整合，大幅提升生產力。
透過 llama.cpp 的進階參數控制，發揮硬體的極限效能。
使用 AnythingLLM 建置能處理機密資料、安全可靠的本地 RAG 系統。
活用 Unsloth (WSL2)，培育出擁有您專屬專業知識的客製化 AI。

AI 的「民主化」不再只是一個流行語（Buzzword），而是真實在您的 Windows 桌面系統上運作的系統。擺脫雲端 API 的使用成本與資料外洩風險，現在就踏入自由且強大的私有 AI 世界吧。