LLM on kenji.blog

llama.cpp使用方法与C++定制入门

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

近年来，大型语言模型（LLM）的进化非常迅猛，其应用范围每天都在扩大。然而，要在本地环境中运行拥有数十亿、数百亿参数的模型，通常需要配备海量显存的高端GPU。打破这种“硬件壁垒”，让在普通PC、Mac甚至像Raspberry Pi这样的设备上进行LLM的实用推理成为可能的，就是 llama.cpp。

本文不仅将介绍仅仅作为命令行工具的使用方法，还将面向工程师极其详细地解析其底层技术 ggml 的架构、Transformer与量化的数学背景，以及如何利用 C++ API 将 LLM 嵌入到自有应用程序并进行定制。

1. llama.cpp 与 ggml 概述

llama.cpp 是由 Georgi Gerganov 开发的、使用 C/C++ 编写的轻量级 LLM 推理引擎。它最初的目的是为了让 Meta 的 LLaMA 模型在 Apple Silicon (M1/M2 Mac) 上高速运行，但现在已支持各种架构和模型。

它最大的特点在于它是纯粹的 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}$，Query $Q$、Key $K$、Value $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["用户输入 (String)"] --> B["llama.cpp Tokenizer"] B --> C["Token IDs (int32 array)"] C --> D["上下文缓冲区 (KV Cache)"] D --> E["ggml 计算图"] E --> F["Transformer 层"] subgraph "ggml 引擎" F --> G["Self-Attention (RoPE)"] G --> H["前馈神经网络 (Feed Forward Network)"] 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 -. "自回归循环 (Auto-regressive loop)" .-> 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 必要的包含与配置

在自己的项目中使用 llama.cpp 时，包含以下内容：

 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 缓存）。

 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 提示词的分词 (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 缓存，预测下一个 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;
}

这段代码是使用 llama.cpp 的基本 API 实现的自定义推理循环。它使用 llama_batch 结构体来管理 Token 群组，并通过 llama_decode 执行神经网络的前向传播 (Forward Pass)。

6. 高级定制案例: 使用 C++ 操作 Logit 与控制惩罚

如果不仅仅停留在简单的文本生成，而是想强制其输出特定格式（例如仅限 JSON），或者防止其输出特定的违禁词，可以在 C++ 端直接在采样前操作 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和本地（On-premises）环境中运行的“本地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格式的全面普及: 将元数据和张量（Tensor）整合到单一文件中的GGUF（GPT-Generated Unified Format）已经完全成为事实上的标准。这使得只需从Hugging Face下载一个文件，就可以在任何环境中运行。
MoE（Mixture of Experts）架构的民主化: 发布了许多规模较小但性能卓越的MoE模型。通过在推理时仅激活部分专家网络，可以在控制消费级PC计算负载的同时，实现媲美巨大模型的性能。
推理引擎的高度抽象化和优化: Ollama、LM Studio、AnythingLLM等工具变得更加完善，用户无需再关注安装CUDA驱动等复杂的依赖关系。此外，随着FlashAttention 3原生支持Windows，推理速度得到了急剧提升。
NPU的应用和Windows Copilot+ PC的崛起: 即使是在没有GPU的笔记本电脑上，利用内置的NPU（神经网络处理单元）以低功耗运行小型LLM（SLM: Small Language Models）的技术也已经进入实用阶段。

2. 硬件要求与操作系统准备

为了以实用的速度（每秒15到30个Token以上）运行本地LLM，硬件的选择最为关键。

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推理或卸载（Offloading）时的决定性瓶颈。DDR5-6000以上的快速内存是理想选择。
GPU: NVIDIA RTX 4000/5000系列。对于本地LLM来说，最重要的不是计算性能，而是“VRAM容量”。
- 入门级: RTX 4060 Ti (16GB版) - 性价比最高。非常适合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推理流水线（Pipeline）。

graph TD User["用户输入 (Prompt)"] --> 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（提示词处理）阶段: 这是一个一次性处理和理解输入的完整提示词（Prompt）的阶段。由于可以进行并行计算，GPU的计算能力（FLOPS）直接影响速度。如果提示词很长，此阶段可能需要几秒钟的时间。
Decode（Token生成）阶段: 这是一个逐个预测Token，并将其作为下一次输入的（自回归）阶段。在这个阶段并行计算受到限制，因此GPU的VRAM带宽（Memory Bandwidth）成为了决定性的瓶颈。

4. VRAM消耗量的计算与模型大小的数学理解

为了准确判断“我的PC能运行哪个模型？”，必须理解VRAM的计算公式。如果由于VRAM不足而导致回退（Fallback）到系统内存（RAM），推理速度将会变慢10倍到100倍。

4.1 基于参数大小的基础VRAM

这是将模型的权重（Weights）加载到VRAM中所需的内存量。使用模型大小 $P$ （参数数量，单位：10亿 = 1B）和每个参数的字节数 $B$ 来计算。

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

例如，要将8B（80亿）参数的模型以FP16（半精度浮点数，16位=2字节）加载时：

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

也就是说，即使拥有16GB的VRAM的GPU，仅加载模型就几乎达到了极限。

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端点。在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 来托管模型。

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的构建

如果您对命令行有抵触情绪，或者想要直观地进行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["生成提示词"] RetrievedDocs --> PromptBuilder PromptBuilder --> LocalLLM["本地 LLM"] LocalLLM --> Answer["最终回答"]

使用AnythingLLM桌面版（Windows），只需在设置界面中指定Ollama（用于LLM和Embedding），并设置为使用本地VectorDB（LanceDB），几分钟内就能完成这个架构的搭建。一个完全不向外部发送任何数据的私有AI就此诞生。

8. 在Windows WSL2上进行微调 (LoRA)

除了在本地运行，如果您还想用自己的数据让模型变得更聪明，可以使用LoRA（低秩自适应）进行微调。在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库相比，训练速度约为原来的2倍，而VRAM消耗量减少了一半左右。启动Jupyter Notebook并加载数据集（JSONL格式）后，即使是使用VRAM为12GB至16GB的RTX 4060 Ti等显卡，也可以完成几个Epoch的训练。

9. 性能与故障排除

以下是经常遇到的问题及其解决方案。

1. 推理速度极慢（1至2 tokens/s）

原因: 模型无法完全装入VRAM，被卸载到了系统内存（RAM）中。对策: 请在任务管理器中检查“专用GPU内存”。如果已达到极限，请减小上下文大小（-c），或者使用位数更低的量化模型（如Q4_K_M等）。

2. “CUDA out of memory” 错误

原因: VRAM完全枯竭。特别是当对话时间过长导致KV缓存不断膨胀时会发生这种情况。对策: 在Ollama中，有意地减小 num_ctx 的值；在llama.cpp中，减小 -c 的值以进行限制。

3. 生成的日语不正常

原因: 提示词模板不匹配，或者是使用了不支持的模型。对策: 请使用模型名称中包含 Instruct 的模型，并确认工具端是否选择了模型作者指定的正确模板，例如ChatML或Llama3格式。

10. 总结与未来展望

在2026年，在Windows环境中构建本地LLM已经不再是少数工程师的特权。随着GGUF格式成为事实上的标准、Ollama和LM Studio等完善生态系统的出现，以及以FlashAttention为首的硬件优化，任何人都可以轻松获得企业级的AI环境。

请务必活用本文中解说的以下几点：

使用VRAM的数学计算，逻辑性地选择最适合您PC规格的模型大小和量化级别。
使用Ollama以最快的速度搭建环境，并与AI编辑器联动，从而急剧提高生产力。
通过llama.cpp的高级参数控制，榨干硬件的极限性能。
使用AnythingLLM构建能够处理机密数据的安全的本地RAG系统。
活用Unsloth (WSL2)，培育出拥有专属于您专业知识的自定义AI。

AI的“民主化”已经不再是一个流行语，而是一个运行在您的Windows桌面上的真实系统。摆脱云端API的使用成本和信息泄露风险，现在就请迈入这个自由且强大的私有AI世界吧。