小语言模型与端侧AI部署完全教程
从模型选型到移动端落地，一站式掌握小语言模型（SLM）的量化、部署与优化全流程。
目录
- 小语言模型概述与发展趋势
- 主流小语言模型对比
- 模型量化技术详解
- Ollama 本地部署实战
- llama.cpp 编译与使用
- 移动端部署方案
- 边缘设备部署
- ONNX Runtime 优化
- 模型蒸馏原理与实践
- 端侧AI应用场景与性能优化
1. 小语言模型概述与发展趋势
1.1 什么是小语言模型（SLM）
小语言模型（Small Language Model, SLM）通常指参数量在 1B 到 10B 之间的语言模型。与 GPT-4、Claude 等动辄数百亿甚至万亿参数的大模型相比，SLM 在保持可观性能的同时，大幅降低了计算资源需求。
核心特征：
| 特征 | 大语言模型（LLM） | 小语言模型（SLM） |
|---|---|---|
| 参数量 | 70B - 1T+ | 1B - 10B |
| 推理资源 | 多卡 GPU 集群 | 单卡 GPU / CPU |
| 部署位置 | 云端 | 端侧 / 边缘 |
| 延迟 | 100ms - 数秒 | 10ms - 500ms |
| 隐私性 | 数据上传云端 | 数据本地处理 |
| 成本 | 高（按 token 计费） | 低（一次性部署） |
1.2 发展趋势
2023-2025 年 SLM 领域的关键趋势：
性能逼近大模型：Phi-3 Mini（3.8B）在多项基准测试上接近 Mixtral 8x7B 的表现，证明了高质量数据可以弥补参数量的不足。
端侧部署成为主流：Apple Intelligence、Google Gemini Nano 等端侧 AI 方案的推出，标志着 SLM 正在从实验室走向数十亿用户的设备。
专用模型涌现：针对代码生成（DeepSeek-Coder）、数学推理（Mathstral）、医疗问答等垂直领域的小模型不断出现。
开源生态繁荣：Hugging Face 上超过 100 万个模型，其中大部分是可端侧部署的小模型。
硬件协同优化：NPU（神经网络处理单元）在手机芯片中的普及（如骁龙 8 Gen 3、天玑 9300），为端侧推理提供了专用算力。
1.3 为什么选择 SLM
选择小语言模型的核心理由：
隐私保护：数据不出设备，满足 GDPR 等合规要求
离线可用：无需网络连接，适合弱网或无网环境
低延迟：本地推理延迟可控，用户体验更流畅
成本优势：无需支付 API 调用费用，长期使用成本低
可控性强：模型版本、输出行为完全由开发者掌控
2. 主流小语言模型对比
2.1 模型概览
以下是 2024-2025 年最具代表性的小语言模型：
Phi-3 / Phi-4 系列（Microsoft）
- 参数量：Mini (3.8B)、Small (7B)、Medium (14B)
- 特点：高质量合成数据训练，在推理任务上表现出色
- 许可证：MIT License
- 上下文窗口：4K（可扩展至 128K）
Gemma 2（Google）
- 参数量：2B、9B、27B
- 特点：基于 Gemini 技术蒸馏，多语言支持优秀
- 许可证：Gemma License（商用友好）
- 上下文窗口：8K
Qwen2.5 系列（Alibaba）
- 参数量：0.5B、1.5B、3B、7B、14B、32B、72B
- 特点：中文能力极强，工具调用支持好，覆盖全尺寸
- 许可证：Apache 2.0
- 上下文窗口：128K
Llama 3.2（Meta）
- 参数量：1B、3B（文本）、11B、90B（多模态）
- 特点：Meta 开源力作，社区生态最完善
- 许可证：Llama 3.2 License
- 上下文窗口：128K
Mistral 系列（Mistral AI）
- 参数量：7B、8x7B（Mixtral）、8x22B
- 特点：稀疏混合专家架构，推理效率高
- 许可证：Apache 2.0（部分模型）
- 上下文窗口：32K
2.2 基准测试对比
以下数据基于公开基准测试结果（2025 年初数据），供参考：
模型 MMLU HumanEval GSM8K 中文能力 端侧友好度
Phi-3 Mini 3.8B 75.7 58.5 82.5 ★★★ ★★★★★
Gemma 2 9B 75.2 54.3 76.8 ★★★ ★★★★
Qwen2.5 7B 74.2 62.0 83.1 ★★★★★ ★★★★
Llama 3.2 3B 63.4 48.2 67.5 ★★★ ★★★★★
Mistral 7B 75.3 55.2 78.9 ★★★ ★★★★
2.3 选型建议
def select_model(requirements: dict) -> str:
"""根据需求选择合适的 SLM"""
if requirements.get("device") == "mobile":
if requirements.get("ram_limit_gb", 4) < 2:
return "Qwen2.5-0.5B 或 Llama 3.2 1B"
else:
return "Phi-3 Mini 3.8B 或 Llama 3.2 3B"
if requirements.get("language") == "chinese":
return "Qwen2.5 系列（中文能力最强）"
if requirements.get("task") == "code_generation":
return "Qwen2.5-Coder-7B 或 DeepSeek-Coder-V2-Lite"
if requirements.get("task") == "reasoning":
return "Phi-3 Mini 或 Phi-4 Mini"
if requirements.get("need_long_context"):
return "Qwen2.5-7B (128K context)"
return "Llama 3.2 3B（通用场景最佳平衡）"
3. 模型量化技术详解
3.1 量化基础
量化（Quantization）是将模型权重从高精度浮点数（如 FP32、FP16）转换为低精度表示（如 INT8、INT4）的技术。这是端侧部署的关键技术。
量化的核心原理：
原始 FP16 权重: [0.1234, -0.5678, 0.9012, ...]
↓ 量化映射
INT4 量化值: [3, -7, 12, ...] + scale + zero_point
↓ 反量化
还原近似值: [0.1250, -0.5625, 0.9000, ...]
常见量化精度与效果：
| 量化精度 | 模型体积缩减 | 精度损失 | 推理速度提升 |
|---|---|---|---|
| FP16 → INT8 | 约 50% | 极小 | 1.5-2x |
| FP16 → INT4 | 约 75% | 较小 | 2-3x |
| FP16 → INT2 | 约 87.5% | 显著 | 3-4x |
3.2 GPTQ 量化
GPTQ（GPT Quantization）是一种基于近似二阶信息的训练后量化方法，能够在极低比特下保持较高精度。
核心思想： 逐层量化权重矩阵，每次量化一个权重时，调整尚未量化的权重来补偿误差。
# 使用 AutoGPTQ 进行 GPTQ 量化
from auto_gptq import AutoGPTQForCausalLM, BaseQuantizeConfig
from transformers import AutoTokenizer
model_id = "Qwen/Qwen2.5-7B-Instruct"
quantize_config = BaseQuantizeConfig(
bits=4, # 量化位数：2, 3, 4, 8
group_size=128, # 量化分组大小，越小精度越高
damp_percent=0.01, # Hessian 矩阵阻尼系数
desc_act=True, # 按激活值降序量化，精度更高
sym=False, # 非对称量化
)
# 加载模型
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoGPTQForCausalLM.from_pretrained(
model_id,
quantize_config
)
# 准备校准数据（用于计算最优量化参数）
calibration_data = [
"这是一段用于量化校准的示例文本。",
"模型量化需要少量代表性数据来优化精度。",
# ... 建议 128-512 条校准样本
]
# 执行量化
model.quantize(calibration_data)
# 保存量化模型
model.save_quantized("./qwen2.5-7b-gptq-4bit")
tokenizer.save_pretrained("./qwen2.5-7b-gptq-4bit")
GPTQ 优势： INT4 下精度损失小，GPU 推理速度快。
GPTQ 劣势： 校准过程较慢，不支持 CPU 推理。
3.3 AWQ 量化
AWQ（Activation-aware Weight Quantization）是一种基于激活值感知的量化方法。其核心洞察是：并非所有权重同等重要，应该保护那些对激活值影响最大的权重通道。
# 使用 AutoAWQ 进行量化
from awq import AutoAWQForCausalLM
from transformers import AutoTokenizer
model_path = "microsoft/Phi-3-mini-4k-instruct"
quant_path = "./phi3-mini-awq-4bit"
# 加载模型和分词器
model = AutoAWQForCausalLM.from_pretrained(model_path)
tokenizer = AutoTokenizer.from_pretrained(model_path)
# 量化配置
quant_config = {
"zero_point": True, # 使用零点量化
"q_group_size": 128, # 量化分组大小
"w_bit": 4, # 权重位数
"version": "GEMM", # GEMM 内核，适合 GPU
}
# 执行量化（需要校准数据）
model.quantize(
tokenizer,
quant_config=quant_config,
calib_data="pileval", # 使用内置校准数据集
)
# 保存
model.save_quantized(quant_path)
tokenizer.save_pretrained(quant_path)
AWQ vs GPTQ：
- AWQ 量化速度更快（无需逐层优化）
- AWQ 在低比特（2-3 bit）下精度更好
- AWQ 对长序列输入更鲁棒
- 两者都需要 GPU 进行推理
3.4 GGUF 量化
GGUF（GPT-Generated Unified Format）是 llama.cpp 使用的模型格式，支持 CPU 和 GPU 混合推理，是端侧部署最常用的格式。
# 方法一：使用 llama.cpp 的量化工具
# 先将 Hugging Face 模型转换为 GGUF 格式
python convert_hf_to_gguf.py \
./Qwen2.5-7B-Instruct \
--outfile qwen2.5-7b-f16.gguf \
--outtype f16
# 然后进行量化（支持多种量化级别）
./llama-quantize \
qwen2.5-7b-f16.gguf \
qwen2.5-7b-q4_k_m.gguf \
Q4_K_M
# 方法二：使用 Ollama 的 Modelfile
# 创建 Modelfile
cat > Modelfile << 'EOF'
FROM qwen2.5-7b-f16.gguf
PARAMETER temperature 0.7
PARAMETER num_ctx 4096
TEMPLATE "{{ .System }}\n{{ .Prompt }}"
EOF
ollama create my-qwen -f Modelfile
GGUF 量化类型说明：
量化类型 大小(7B) 质量 速度 适用场景
Q2_K ~2.8 GB ★★ 最快 极端资源受限
Q3_K_M ~3.5 GB ★★★ 快 低配设备
Q4_0 ~4.0 GB ★★★ 快 通用基准
Q4_K_M ~4.5 GB ★★★★ 快 ⭐推荐默认选择
Q5_K_M ~5.3 GB ★★★★★ 中 质量优先
Q6_K ~6.0 GB ★★★★★ 中 高质量需求
Q8_0 ~7.5 GB ★★★★★ 较慢 最高质量
3.5 量化方案选型决策树
需要端侧部署？
├── 是 → 设备类型？
│ ├── 仅有 CPU → GGUF（llama.cpp / Ollama）
│ ├── 有 GPU（手机/边缘）→ GGUF 或 ONNX INT4
│ └── 有 NPU → ONNX（厂商 SDK）
└── 否 → 有 GPU 服务器？
├── 是 → GPTQ 或 AWQ（vLLM / TGI 部署）
└── 否 → GGUF CPU 部署
4. Ollama 本地部署实战
4.1 Ollama 简介
Ollama 是当前最流行的本地大模型运行工具，它将模型下载、量化、推理封装为一个简单的命令行工具，支持 macOS、Linux、Windows。
4.2 安装与配置
# Linux / macOS 一键安装
curl -fsSL https://ollama.com/install.sh | sh
# 验证安装
ollama --version
# 启动 Ollama 服务
ollama serve # 默认监听 http://localhost:11434
4.3 模型管理
# 拉取模型（自动下载最优量化版本）
ollama pull qwen2.5:7b
ollama pull phi3:mini
ollama pull llama3.2:3b
ollama pull gemma2:9b
# 查看已下载模型
ollama list
# 查看模型详细信息
ollama show qwen2.5:7b
# 删除模型
ollama rm phi3:mini
4.4 交互式使用
# 直接对话
ollama run qwen2.5:7b
# 带系统提示词运行
ollama run qwen2.5:7b "你是一个Python专家，请解释装饰器的工作原理"
# 使用管道
echo "总结以下文章的要点" | ollama run qwen2.5:7b
cat article.txt | ollama run qwen2.5:7b "总结要点"
4.5 API 调用
Ollama 提供兼容 OpenAI 格式的 API：
import requests
import json
# 方式一：Ollama 原生 API
def chat_with_ollama(prompt: str, model: str = "qwen2.5:7b") -> str:
response = requests.post(
"http://localhost:11434/api/chat",
json={
"model": model,
"messages": [
{"role": "system", "content": "你是一个有帮助的AI助手。"},
{"role": "user", "content": prompt}
],
"stream": False,
"options": {
"temperature": 0.7,
"num_ctx": 4096,
"num_predict": 512,
}
}
)
return response.json()["message"]["content"]
# 方式二：兼容 OpenAI SDK
from openai import OpenAI
client = OpenAI(
base_url="http://localhost:11434/v1",
api_key="ollama" # Ollama 不需要真实 key
)
response = client.chat.completions.create(
model="qwen2.5:7b",
messages=[
{"role": "system", "content": "你是一个代码助手。"},
{"role": "user", "content": "用Python实现快速排序"}
],
temperature=0.7,
max_tokens=1024
)
print(response.choices[0].message.content)
# 流式输出
stream = client.chat.completions.create(
model="qwen2.5:7b",
messages=[{"role": "user", "content": "讲个故事"}],
stream=True
)
for chunk in stream:
if chunk.choices[0].delta.content:
print(chunk.choices[0].delta.content, end="", flush=True)
4.6 自定义 Modelfile
# Modelfile - 自定义模型配置
FROM qwen2.5:7b
# 系统提示词
SYSTEM """
你是一个专业的技术文档撰写助手。请使用清晰、简洁的中文回答问题。
回答时遵循以下规则：
1. 使用 Markdown 格式
2. 包含代码示例（如果适用）
3. 给出最佳实践建议
"""
# 模型参数
PARAMETER temperature 0.7
PARAMETER top_p 0.9
PARAMETER top_k 40
PARAMETER num_ctx 8192
PARAMETER num_predict 2048
PARAMETER repeat_penalty 1.1
# 停止词
PARAMETER stop "<|end|>"
PARAMETER stop "<|user|>"
# 模板
TEMPLATE """{{ if .System }}<|system|>
{{ .System }}<|end|>
{{ end }}{{ if .Prompt }}<|user|>
{{ .Prompt }}<|end|>
{{ end }}<|assistant|>
{{ .Response }}<|end|>"""
# 创建自定义模型
ollama create tech-writer -f Modelfile
# 测试
ollama run tech-writer "解释什么是向量数据库"
4.7 GPU 加速配置
# 检查 GPU 是否可用
nvidia-smi
# Ollama 自动检测 GPU，可通过环境变量控制
export OLLAMA_GPU_LAYERS=35 # 指定 GPU 加载的层数
export OLLAMA_NUM_PARALLEL=2 # 并行请求数
export OLLAMA_MAX_LOADED_MODELS=2 # 最大同时加载模型数
# Apple Silicon（MPS 加速）
# macOS 上 Ollama 自动使用 Metal 加速，无需额外配置
5. llama.cpp 编译与使用
5.1 llama.cpp 简介
llama.cpp 是 Georgi Gerganov 开发的纯 C/C++ 推理引擎，无需 Python 依赖，支持 CPU（含 AVX2/NEON 优化）和 GPU（CUDA/Metal/Vulkan）推理，是端侧部署的基础工具。
5.2 编译安装
# 克隆仓库
git clone https://github.com/ggerganov/llama.cpp.git
cd llama.cpp
# CPU 编译（Linux/macOS）
cmake -B build
cmake --build build --config Release -j$(nproc)
# CUDA 编译（NVIDIA GPU）
cmake -B build -DGGML_CUDA=ON
cmake --build build --config Release -j$(nproc)
# Metal 编译（Apple Silicon）
cmake -B build -DGGML_METAL=ON
cmake --build build --config Release
# Vulkan 编译（通用 GPU）
cmake -B build -DGGML_VULKAN=ON
cmake --build build --config Release -j$(nproc)
# 验证
./build/bin/llama-cli --version
5.3 模型转换与量化
# 步骤 1：将 Hugging Face 模型转换为 GGUF
python3 convert_hf_to_gguf.py \
/path/to/huggingface/model \
--outfile model-f16.gguf \
--outtype f16
# 步骤 2：量化（常用级别）
# Q4_K_M - 推荐的平衡选择
./build/bin/llama-quantize \
model-f16.gguf \
model-q4_k_m.gguf \
Q4_K_M
# Q8_0 - 高质量
./build/bin/llama-quantize \
model-f16.gguf \
model-q8_0.gguf \
Q8_0
# 查看模型信息
./build/bin/llama-cli -m model-q4_k_m.gguf --info
5.4 推理与对话
# 交互式对话
./build/bin/llama-cli \
-m model-q4_k_m.gguf \
-c 4096 \
-t 4 \
--temp 0.7 \
-p "你是一个有帮助的AI助手。\n\n用户：请解释什么是机器学习。\n助手："
# 从文件读取提示词
./build/bin/llama-cli \
-m model-q4_k_m.gguf \
-c 4096 \
-f prompt.txt
# 批量推理
echo "问题1" | ./build/bin/llama-cli -m model-q4_k_m.gguf -c 2048 -n 256 --no-display-prompt
5.5 启动 API 服务器
# 启动兼容 OpenAI 的 API 服务
./build/bin/llama-server \
-m model-q4_k_m.gguf \
--host 0.0.0.0 \
--port 8080 \
-c 4096 \
-t 4 \
--n-gpu-layers 35 # GPU 加速层数
# 测试 API
curl http://localhost:8080/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
"model": "local-model",
"messages": [
{"role": "user", "content": "你好，介绍一下你自己"}
],
"temperature": 0.7
}'
5.6 性能调优参数
# 关键性能参数
./build/bin/llama-cli \
-m model-q4_k_m.gguf \
-c 4096 \ # 上下文长度
-t 4 \ # CPU 线程数（建议 = CPU 核心数）
-ngl 99 \ # GPU 加速层数（99 = 全部层）
-b 512 \ # 批处理大小
-ub 512 \ # 提示词批处理大小
--mlock \ # 锁定内存，避免换页
--no-mmap \ # 禁用内存映射（小内存设备）
--flash-attn \ # Flash Attention（需要编译支持）
-np 2 # 并行槽位数
6. 移动端部署方案
6.1 Android 部署
使用 llama.cpp 的 Android 方案
// build.gradle.kts 依赖配置
dependencies {
implementation("com.google.mediapipe:tasks-genai:0.10.18")
// 或使用 llama.cpp JNI 绑定
implementation("com.llama.cpp:llama-android:1.0.0")
}
// MainActivity.kt - 使用 MediaPipe LLM Inference
class MainActivity : AppCompatActivity() {
private lateinit var llmInference: LlmInference
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
// 初始化 LLM 推理引擎
val options = LlmInference.LlmInferenceOptions.builder()
.setModelPath(getModelPath("qwen2.5-3b-q4.gguf"))
.setMaxTokens(512)
.setResultListener { partialResult, done ->
runOnUiThread {
textView.append(partialResult)
}
}
.build()
llmInference = LlmInference.createFromOptions(this, options)
// 发送请求
button.setOnClickListener {
val prompt = editText.text.toString()
textView.text = ""
llmInference.generateResponseAsync(prompt)
}
}
private fun getModelPath(assetName: String): String {
// 从 assets 复制模型到内部存储
val file = File(filesDir, assetName)
if (!file.exists()) {
assets.open(assetName).use { input ->
file.outputStream().use { output ->
input.copyTo(output)
}
}
}
return file.absolutePath
}
}
使用 MLC LLM 的 Android 方案
# 首先在 Python 环境中编译 Android 模型
import mlc_llm
import mlc_ai
# 编译模型为 Android 可用格式
model = "HF://mlc-ai/Qwen2.5-3B-Instruct-q4f16_1-MLC"
target = "android"
# 编译
mlc_llm.compile(
model=model,
target=target,
quantization="q4f16_1",
opt_level=3,
system_lib=False,
output="android_lib"
)
6.2 iOS 部署
使用 MLX Swift（Apple 原生框架）
// Package.swift
dependencies: [
.package(url: "https://github.com/ml-explore/mlx-swift", from: "0.18.0"),
.package(url: "https://github.com/ml-explore/mlx-swift-examples", from: "0.18.0"),
]
// LLMManager.swift
import MLX
import MLXLLM
import MLXNN
class LLMManager: ObservableObject {
@Published var output = ""
private var model: LLMModel?
private var tokenizer: Tokenizer?
func loadModel() async throws {
// 加载量化后的模型
let modelPath = Bundle.main.path(
forResource: "qwen2.5-3b-4bit",
ofType: "mlx"
)!
let config = try loadConfig(path: modelPath)
model = try LLMModel.load(config: config)
tokenizer = try loadTokenizer(path: modelPath)
// 将模型移至 GPU（Apple Neural Engine）
model = model?.toGPU()
}
func generate(prompt: String) async throws {
let tokens = try tokenizer!.encode(text: prompt)
let stream = try model!.generate(
tokens: tokens,
parameters: GenerateParameters(
temperature: 0.7,
topP: 0.9,
maxTokens: 512
)
)
for try await token in stream {
let text = tokenizer!.decode(tokens: [token])
await MainActor.run {
output += text
}
}
}
}
// ContentView.swift
struct ContentView: View {
@StateObject private var llm = LLMManager()
@State private var input = ""
var body: some View {
VStack {
ScrollView {
Text(llm.output)
.padding()
}
HStack {
TextField("输入问题...", text: $input)
.textFieldStyle(.roundedBorder)
Button("发送") {
Task {
try await llm.generate(prompt: input)
}
}
}
.padding()
}
.task {
try? await llm.loadModel()
}
}
}
使用 llama.cpp iOS 绑定
// 通过 Swift Package Manager 引入 llama.cpp
// LlamaRunner.swift
import llama
class LlamaRunner {
private var context: OpaquePointer?
private var model: OpaquePointer?
func loadModel(path: String) {
var params = llama_model_default_params()
params.n_gpu_layers = 99 // Metal 加速
model = llama_load_model_from_file(path, params)
var ctxParams = llama_context_default_params()
ctxParams.n_ctx = 4096
ctxParams.n_threads = 8 // Apple Silicon 性能核心数
context = llama_new_context_with_model(model, ctxParams)
}
func generate(prompt: String, maxTokens: Int = 256) -> String {
// Tokenize 输入
let tokens = tokenize(prompt)
// 评估提示词
llama_eval(context, tokens, Int32(tokens.count), 0)
// 自回归生成
var result = ""
var pos = tokens.count
for _ in 0..<maxTokens {
let nextToken = sampleToken()
if nextToken == llama_token_eos(model) { break }
let text = detokenize([nextToken])
result += text
llama_eval(context, [nextToken], 1, Int32(pos))
pos += 1
}
return result
}
func unload() {
if let ctx = context { llama_free(ctx) }
if let m = model { llama_free_model(m) }
}
}
6.3 移动端性能优化
# 移动端部署优化清单
optimization_checklist = {
"模型选择": {
"参数量": "≤ 3B（推荐 1B-3B）",
"量化": "Q4_K_M 或 Q4_0",
"上下文": "限制 2048-4096 tokens",
"模型格式": "GGUF（通用）或 MLX（iOS）"
},
"内存优化": {
"模型大小": "Q4 量化后约 1.5-2.5 GB（3B 模型）",
"KV Cache": "使用 KV Cache 量化（Q8 或 Q4）",
"内存映射": "mmap 加载，避免完整加载到 RAM",
},
"速度优化": {
"批处理": "单请求，不做批处理",
"线程数": "设置为大核数量（非全部核心）",
"GPU 层": "尽可能多的层放到 GPU/NPU",
"Flash Attention": "如果硬件支持，启用 FA",
},
"用户体验": {
"流式输出": "逐 token 显示，降低感知延迟",
"后台加载": "应用启动时预加载模型",
"进度提示": "显示加载进度和生成状态",
}
}
7. 边缘设备部署
7.1 树莓派部署
硬件要求
推荐配置：
- 树莓派 5（8GB RAM）
- 高速 microSD（A2 级别）或 NVMe SSD
- 散热片 + 风扇（推理时 CPU 满载）
- USB-C 电源（5V/5A）
部署步骤
# 1. 系统准备（Raspberry Pi OS 64-bit）
sudo apt update && sudo apt upgrade -y
sudo apt install -y cmake git build-essential
# 2. 编译 llama.cpp（ARM NEON 优化）
git clone https://github.com/ggerganov/llama.cpp.git
cd llama.cpp
cmake -B build -DGGML_NEON=ON -DCMAKE_BUILD_TYPE=Release
cmake --build build --config Release -j4
# 3. 下载适合树莓派的小模型
# 推荐：Qwen2.5-1.5B 或 Llama 3.2 1B 的 Q4_K_M 量化
wget https://huggingface.co/Qwen/Qwen2.5-1.5B-Instruct-GGUF/resolve/main/qwen2.5-1.5b-instruct-q4_k_m.gguf
# 4. 运行推理
./build/bin/llama-cli \
-m qwen2.5-1.5b-instruct-q4_k_m.gguf \
-c 2048 \
-t 4 \
--mlock \
-p "用户：用简单的语言解释太阳系。\n助手："
树莓派性能参考
模型 量化 推理速度(树莓派5) 内存占用
Qwen2.5-0.5B Q4_K_M ~15 tokens/s ~0.5 GB
Qwen2.5-1.5B Q4_K_M ~8 tokens/s ~1.2 GB
Llama 3.2 1B Q4_K_M ~10 tokens/s ~0.8 GB
Phi-3 Mini 3.8B Q4_K_M ~3 tokens/s ~2.8 GB
7.2 NVIDIA Jetson 部署
Jetson Orin Nano 部署
# 1. 确认 CUDA 版本
nvcc --version
# JetPack 6.x 默认 CUDA 12.x
# 2. 编译 llama.cpp（CUDA 加速）
git clone https://github.com/ggerganov/llama.cpp.git
cd llama.cpp
cmake -B build -DGGML_CUDA=ON -DCMAKE_CUDA_ARCHITECTURES="87"
# Jetson Orin 的 CUDA 架构是 8.7
cmake --build build --config Release -j$(nproc)
# 3. 运行模型（利用 GPU 加速）
./build/bin/llama-cli \
-m qwen2.5-7b-instruct-q4_k_m.gguf \
-c 4096 \
-ngl 99 \
-t 6 \
--flash-attn
Jetson 性能优化
# Jetson 功耗模式设置
import subprocess
# 设置最大性能模式（15W/25W/30W 根据型号）
subprocess.run(["sudo", "nvpmodel", "-m", "0"]) # MAXN 模式
subprocess.run(["sudo", "jetson_clocks"]) # 锁定最大频率
# Jetson 设备性能参考
jetson_benchmarks = {
"Orin Nano 8GB": {
"Qwen2.5-3B Q4": "~15 tokens/s",
"Qwen2.5-7B Q4": "~6 tokens/s",
"Llama 3.2 3B Q4": "~18 tokens/s",
},
"Orin NX 16GB": {
"Qwen2.5-7B Q4": "~12 tokens/s",
"Phi-3 Mini Q4": "~15 tokens/s",
},
"AGX Orin 64GB": {
"Qwen2.5-14B Q4": "~10 tokens/s",
"Llama 3.1 8B Q4": "~20 tokens/s",
}
}
7.3 其他边缘设备
# Orange Pi / Rockchip RK3588
# RK3588 有 6 TOPS NPU，可使用 RKNN 加速
cmake -B build -DGGML_RKNPU=ON
cmake --build build --config Release
# Intel NUC / 迷你 PC（使用 OpenVINO）
pip install openvino
optimum-cli export openvino \
--model Qwen/Qwen2.5-3B-Instruct \
--task text-generation \
./ov_qwen2.5_3b
8. ONNX Runtime 优化
8.1 ONNX Runtime 简介
ONNX Runtime（ORT）是微软开源的高性能推理引擎，支持多种硬件后端（CPU、CUDA、TensorRT、DirectML、CoreML），特别适合跨平台部署。
8.2 模型转换
from optimum.onnxruntime import ORTModelForCausalLM
from transformers import AutoTokenizer
# 使用 Optimum 将模型导出为 ONNX
model_id = "Qwen/Qwen2.5-3B-Instruct"
# 导出 FP16 ONNX 模型
model = ORTModelForCausalLM.from_pretrained(
model_id,
export=True,
provider="CPUExecutionProvider", # 或 CUDAExecutionProvider
)
tokenizer = AutoTokenizer.from_pretrained(model_id)
# 保存
model.save_pretrained("./qwen2.5-3b-onnx")
tokenizer.save_pretrained("./qwen2.5-3b-onnx")
8.3 量化优化
from optimum.onnxruntime import ORTQuantizer
from optimum.onnxruntime.configuration import (
AutoQuantizationConfig,
AutoCalibrationConfig,
)
# 加载 ONNX 模型
quantizer = ORTQuantizer.from_pretrained("./qwen2.5-3b-onnx")
# 动态量化（INT8）
qconfig = AutoQuantizationConfig.avx512_vnni(is_static=False, per_channel=True)
quantizer.quantize(
save_dir="./qwen2.5-3b-onnx-int8",
quantization_config=qconfig,
)
# 静态量化（精度更高，需要校准数据）
qconfig_static = AutoQuantizationConfig.avx512_vnni(is_static=True, per_channel=True)
calibration_config = AutoCalibrationConfig.minmax(quantizer.calibrate(train_dataset))
quantizer.quantize(
save_dir="./qwen2.5-3b-onnx-int8-static",
quantization_config=qconfig_static,
calibration_config=calibration_config,
)
8.4 跨平台推理
import onnxruntime as ort
import numpy as np
# 选择最优执行提供者
providers = ort.get_available_providers()
print(f"可用后端: {providers}")
# 按优先级选择
preferred = [
"CUDAExecutionProvider",
"CoreMLExecutionProvider", # macOS/iOS
"DmlExecutionProvider", # Windows DirectML
"CPUExecutionProvider",
]
available = [p for p in preferred if p in providers]
# 创建推理会话
session_options = ort.SessionOptions()
session_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
session_options.intra_op_num_threads = 4
session_options.inter_op_num_threads = 2
session = ort.InferenceSession(
"./qwen2.5-3b-onnx-int8/model.onnx",
sess_options=session_options,
providers=available[:1], # 使用最优后端
)
# 执行推理
def generate_onnx(prompt_ids: list[int], max_tokens: int = 256) -> list[int]:
"""ONNX 自回归生成"""
input_ids = np.array([prompt_ids], dtype=np.int64)
generated = list(prompt_ids)
for _ in range(max_tokens):
outputs = session.run(None, {"input_ids": input_ids})
next_token = int(np.argmax(outputs[0][:, -1, :]))
if next_token == eos_token_id:
break
generated.append(next_token)
input_ids = np.array([generated], dtype=np.int64)
return generated
8.5 移动端 ONNX 部署
# Android - 使用 ONNX Runtime Mobile
# build.gradle
# implementation 'com.microsoft.onnxruntime:onnxruntime-android:1.19.0'
# iOS - 使用 CoreML 或 ONNX Runtime Mobile
# pod 'onnxruntime-objc'
# 导出移动端优化模型
from optimum.onnxruntime import ORTModelForCausalLM
model = ORTModelForCausalLM.from_pretrained(
model_id,
export=True,
provider="CPUExecutionProvider",
# 移动端优化选项
use_merged=False, # 不合并 KV Cache
use_cache=True, # 使用 KV Cache 加速
)
9. 模型蒸馏原理与实践
9.1 蒸馏基础
知识蒸馏（Knowledge Distillation）是将大模型（教师模型）的知识转移到小模型（学生模型）的技术。核心思想是让学生模型不仅学习"正确答案"（硬标签），还学习教师模型的"思考过程"（软标签）。
教师模型（70B） 学生模型（3B）
[复杂推理] ──蒸馏──→ [高效推理]
[丰富知识] ──蒸馏──→ [精华知识]
[细腻理解] ──蒸馏──→ [核心理解]
蒸馏的数学原理：
学生损失 = α × KL(教师soft_output || 学生soft_output)
+ (1-α) × CrossEntropy(学生hard_output, 真实标签)
其中：
- 软标签（soft labels）：教师模型的 logits 经温度 T 平滑后的分布
- 硬标签（hard labels）：真实标签的 one-hot 编码
- α：平衡系数，通常 0.5-0.9
- T：温度参数，通常 2-5
9.2 数据蒸馏实践
最实用的蒸馏方式是用大模型生成高质量训练数据，然后用这些数据微调小模型。
import json
from openai import OpenAI
# 教师模型生成训练数据
teacher_client = OpenAI(
base_url="https://api.deepseek.com/v1",
api_key="your-api-key"
)
def generate_training_data(questions: list[str], output_file: str):
"""使用教师模型生成高质量回答作为训练数据"""
training_data = []
for question in questions:
response = teacher_client.chat.completions.create(
model="deepseek-chat", # 教师模型
messages=[
{
"role": "system",
"content": "你是一个专业的AI助手。请提供详细、准确、有条理的回答。"
},
{"role": "user", "content": question}
],
temperature=0.3, # 低温度，输出更稳定
max_tokens=2048
)
answer = response.choices[0].message.content
training_data.append({
"instruction": question,
"output": answer,
"source": "teacher_distillation"
})
# 保存为训练格式
with open(output_file, "w", encoding="utf-8") as f:
json.dump(training_data, f, ensure_ascii=False, indent=2)
print(f"生成 {len(training_data)} 条训练数据")
# 使用示例
questions = [
"解释量子计算的基本原理",
"如何设计一个高可用的微服务架构？",
"比较 React 和 Vue 的优缺点",
# ... 更多问题
]
generate_training_data(questions, "distill_data.json")
9.3 微调学生模型
from transformers import (
AutoModelForCausalLM,
AutoTokenizer,
TrainingArguments,
Trainer,
)
from datasets import load_dataset
from peft import LoraConfig, get_peft_model
# 加载学生模型
model_id = "Qwen/Qwen2.5-1.5B-Instruct"
model = AutoModelForCausalLM.from_pretrained(
model_id,
torch_dtype="auto",
device_map="auto",
)
tokenizer = AutoTokenizer.from_pretrained(model_id)
# LoRA 配置（参数高效微调）
lora_config = LoraConfig(
r=16,
lora_alpha=32,
target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
"gate_proj", "up_proj", "down_proj"],
lora_dropout=0.05,
bias="none",
task_type="CAUSAL_LM",
)
model = get_peft_model(model, lora_config)
model.print_trainable_parameters()
# 加载蒸馏数据
dataset = load_dataset("json", data_files="distill_data.json")
def format_instruction(sample):
"""格式化训练样本"""
return f"### 问题：\n{sample['instruction']}\n\n### 回答：\n{sample['output']}{tokenizer.eos_token}"
def tokenize_function(examples):
text = format_instruction(examples)
result = tokenizer(
text,
truncation=True,
max_length=2048,
padding="max_length",
)
result["labels"] = result["input_ids"].copy()
return result
tokenized_dataset = dataset.map(tokenize_function, remove_columns=["instruction", "output"])
# 训练配置
training_args = TrainingArguments(
output_dir="./qwen2.5-1.5b-distilled",
num_train_epochs=3,
per_device_train_batch_size=4,
gradient_accumulation_steps=8,
learning_rate=2e-4,
warmup_ratio=0.1,
logging_steps=10,
save_strategy="epoch",
fp16=True,
optim="adamw_torch",
report_to="none",
)
trainer = Trainer(
model=model,
args=training_args,
train_dataset=tokenized_dataset["train"],
)
trainer.train()
# 合并 LoRA 权重并保存
model = model.merge_and_unload()
model.save_pretrained("./qwen2.5-1.5b-distilled-final")
tokenizer.save_pretrained("./qwen2.5-1.5b-distilled-final")
9.4 蒸馏效果评估
import json
def evaluate_distilled_model():
"""评估蒸馏模型的效果"""
test_questions = [
{"q": "什么是RESTful API？", "category": "技术概念"},
{"q": "Python中装饰器的原理是什么？", "category": "编程"},
{"q": "解释CAP定理", "category": "分布式系统"},
]
results = []
for item in test_questions:
# 分别用教师和学生模型回答
teacher_answer = call_model("teacher", item["q"])
student_answer = call_model("student", item["q"])
# 评估（可用 LLM-as-Judge 或人工评估）
score = evaluate_quality(teacher_answer, student_answer)
results.append({
"question": item["q"],
"score": score,
"category": item["category"]
})
# 统计
avg_score = sum(r["score"] for r in results) / len(results)
print(f"平均质量分数: {avg_score:.2f}/10")
print(f"数据集规模影响: 更多蒸馏数据通常带来更好效果")
evaluate_distilled_model()
10. 端侧AI应用场景与性能优化
10.1 典型应用场景
场景一：智能文档助手
# 端侧文档问答系统
class LocalDocAssistant:
def __init__(self, model_path: str):
self.llm = load_model(model_path) # Qwen2.5-3B GGUF
self.embeddings = load_embeddings("bge-small-zh") # 端侧嵌入模型
self.vector_store = SimpleVectorStore()
def index_document(self, doc_path: str):
"""索引本地文档"""
chunks = split_document(doc_path, chunk_size=500)
for chunk in chunks:
embedding = self.embeddings.encode(chunk)
self.vector_store.add(embedding, chunk)
def ask(self, question: str) -> str:
"""基于文档回答问题"""
# 检索相关文档
query_emb = self.embeddings.encode(question)
relevant_chunks = self.vector_store.search(query_emb, top_k=3)
# 构建提示词
context = "\n\n".join(relevant_chunks)
prompt = f"""基于以下文档内容回答问题。如果文档中没有相关信息，请说明。
文档内容：
{context}
问题：{question}
回答："""
return self.llm.generate(prompt, max_tokens=512)
场景二：实时翻译助手
class LocalTranslator:
"""端侧翻译助手 - 无需网络"""
def __init__(self):
# 使用专门的翻译小模型
self.model = load_model("nllb-200-distilled-600M")
def translate(self, text: str, source_lang: str, target_lang: str) -> str:
prompt = f"Translate from {source_lang} to {target_lang}: {text}"
return self.model.generate(prompt, max_tokens=len(text) * 3)
场景三：智能家居语音控制
class SmartHomeController:
"""端侧智能家居控制"""
def __init__(self):
self.llm = load_model("qwen2.5-1.5b-instruct-q4.gguf")
self.stt = load_whisper("whisper-tiny") # 语音识别
self.tts = load_tts("piper-zh") # 语音合成
def process_command(self, audio_input: bytes) -> str:
# 语音转文字
text = self.stt.transcribe(audio_input)
# 理解意图
prompt = f"""将以下用户指令转换为JSON格式的设备控制命令。
设备列表：灯(客厅/卧室/厨房)、空调、电视、窗帘
用户指令：{text}
JSON命令："""
command_json = self.llm.generate(prompt, max_tokens=128)
# 执行命令
result = execute_device_command(command_json)
# 语音反馈
response_text = f"已执行：{result}"
self.tts.speak(response_text)
return response_text
10.2 性能优化最佳实践
内存优化
# 内存优化策略
memory_optimization = {
"KV Cache 量化": {
"方法": "将 KV Cache 从 FP16 量化为 Q8 或 Q4",
"节省": "KV Cache 内存减少 50%-75%",
"实现": "llama.cpp: --cache-type-k q8_0 --cache-type-v q8_0"
},
"Flash Attention": {
"方法": "使用 Flash Attention 减少注意力计算内存",
"节省": "注意力内存从 O(n²) 降到 O(n)",
"实现": "编译时启用 -DGGML_FLASH_ATTN=ON"
},
"动态批处理": {
"方法": "根据输入长度动态调整批处理大小",
"效果": "避免短序列的内存浪费",
},
"模型分片": {
"方法": "大模型跨多设备分片加载",
"场景": "多 GPU 或 GPU+CPU 混合推理",
}
}
推理速度优化
# 推理速度优化技巧
speed_optimization = {
"编译优化": [
"启用目标 CPU 的特定指令集（AVX2/AVX-512/NEON）",
"使用 -O3 优化级别",
"启用链接时优化（LTO）",
],
"运行时优化": [
"设置合理的线程数（通常 = 物理核心数）",
"启用 mlock 防止内存换页",
"使用 mmap 加速模型加载",
"预分配 KV Cache 空间",
],
"模型优化": [
"选择合适的量化级别（Q4_K_M 是最佳平衡）",
"减少不必要的上下文长度",
"使用推测解码（Speculative Decoding）加速",
],
"推测解码示例": {
"原理": "用小模型快速草拟多个 token，大模型一次性验证",
"加速比": "1.5x - 3x",
"代码": """
# llama.cpp 推测解码
./llama-cli \
-m draft-model-q4.gguf \ # 草稿模型（小）
-md target-model-q4.gguf \ # 目标模型（大）
-ngld 99 \ # 草稿模型 GPU 层数
--draft-max 8 # 每次草拟的 token 数
"""
}
}
功耗优化（移动设备）
# 移动设备功耗优化
power_optimization = {
"降低精度": "INT4 量化比 FP16 节省约 75% 计算能耗",
"动态频率": "根据负载动态调整 CPU/GPU 频率",
"批量推理": "延迟非紧急请求，集中处理",
"模型预热": "首次加载后保持常驻，避免重复加载开销",
"后台降级": "应用进入后台时降低推理频率或卸载模型",
}
10.3 部署架构设计
┌─────────────────────────────────────────────────┐
│ 端侧 AI 架构 │
├─────────────────────────────────────────────────┤
│ │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │ 输入层 │ │ 处理层 │ │ 输出层 │ │
│ │ │ │ │ │ │ │
│ │ 文本输入 │→│ 本地模型 │→│ 文本输出 │ │
│ │ 语音输入 │→│ 推理引擎 │→│ 语音输出 │ │
│ │ 图像输入 │→│ 后处理 │→│ 设备控制 │ │
│ └──────────┘ └──────────┘ └──────────┘ │
│ │
│ ┌──────────────────────────────────────────┐ │
│ │ 管理层 │ │
│ │ • 模型生命周期管理（加载/卸载/切换） │ │
│ │ • 内存监控与自动释放 │ │
│ │ • 任务队列与优先级调度 │ │
│ │ • 错误恢复与降级策略 │ │
│ └──────────────────────────────────────────┘ │
│ │
│ ┌──────────────────────────────────────────┐ │
│ │ 存储层 │ │
│ │ • 模型文件存储（量化模型） │ │
│ │ • 会话历史与上下文缓存 │ │
│ │ • 知识库向量索引 │ │
│ └──────────────────────────────────────────┘ │
└─────────────────────────────────────────────────┘
10.4 总结与展望
小语言模型和端侧 AI 正在经历快速发展。关键要点：
- 选型策略：根据设备能力和任务需求选择合适模型，Qwen2.5 和 Llama 3.2 是当前最佳选择
- 量化必做：Q4_K_M 是性价比最高的量化方案，GGUF 格式最适合端侧部署
- 工具链成熟：Ollama、llama.cpp、ONNX Runtime 构成了完整的端侧部署工具链
- 性能可期：在现代移动设备上，3B 参数模型已能达到可用的推理速度
- 趋势明确：随着硬件 NPU 的普及和模型架构的创新，端侧 AI 的能力将持续增强
掌握本教程介绍的技术栈，你将能够在各类端侧设备上成功部署和优化小语言模型，构建真正保护用户隐私、离线可用的 AI 应用。
下一步学习建议：
- 尝试用 Ollama 在本地运行一个小模型，体验推理效果
- 使用 llama.cpp 编译并量化一个模型，对比不同量化级别的效果
- 在 Android 或 iOS 设备上部署一个 1B 参数的模型
- 探索 RAG（检索增强生成）与端侧模型的结合
本教程最后更新：2025年6月
