大语言模型推理端架构与 llama.cpp 核心实现解析

步骤五：推理计算

这是核心步骤，模型根据输入数据生成预测结果。

1. Prompt 阶段：

   • 将转化后的所有词向量进行 Transformer 解码计算。
   • 计算 Q、K、V 矩阵，执行 Self-Attention 机制。
   • 填充 KV Cache，避免重复计算历史 token。

2. Generate 阶段：

   • 根据上一轮生成的结果和前序 Prompt，继续计算下一个 token。
   • 循环执行直到达到停止条件（EOS token 或最大长度）。

关键函数：

• llama_decode(): 执行前向传播计算。
• llama_build_graph(): 构建计算图（部分版本已集成）。
• llama_graph_compute(): 调度算子开始计算。

计算结果是一组概率数组，表示预测下一个 token 的概率分布，存放在 llama_context 中。

步骤六：采样与输出

对预测结果进行后处理，生成人类可读的文本。

1. 采样 (Sampling)：

   • 从概率分布中生成下一个 token_id。
   • 策略包括 Greedy Search（贪婪搜索）、Top-K、Top-P（Nucleus Sampling）等。
   • 函数示例：llama_sampling_sample()。

2. 反序列化：

   • 将 token_id 转换回文本字符。
   • 函数：llama_token_to_piece()。

3. 输出：

   • 打印结果给用户，或返回给 API 客户端。

步骤七：资源释放

清理内存，防止泄漏。

• 调用 llama_free(ctx) 释放上下文。
• 调用 llama_free_model(model) 释放模型权重。

3. 核心代码示例

#include "llama.h"
#include <vector>
#include <string>
#include <iostream>

int main(int argc, char **argv) {
    // 1. 解析参数
    gpt_params params;
    if (!gpt_params_parse(argc, argv, params)) {
        return 1;
    }

    // 2. 加载模型
    llama_model *model = nullptr;
    model = llama_load_model_from_file(params.model.c_str(), params.params);
    if (model == nullptr) {
        fprintf(stderr, "%s: error: unable to load model\n", __func__);
        return 1;
    }

    // 3. 创建上下文
    llama_context *ctx = llama_new_context_with_model(model, params.params);
    if (ctx == nullptr) {
        fprintf(stderr, "%s: error: failed to create context\n", __func__);
        llama_free_model(model);
        return 1;
    }

    // 4. 处理输入 Prompt
    const std::string input = "This is an example input.";
    std::vector<llama_token> embd_input = llama_tokenize(ctx, input, true);

    // 5. 推理
    int n_past = 0;
    for (size_t i = 0; i < embd_input.size(); ++i) {
        llama_eval(ctx, &embd_input[i], 1, n_past, params.n_threads);
        n_past += 1;
    }

    // 6. 采样生成
    std::vector<llama_token> embd_gen;
    while (true) {
        llama_token id = llama_sampling_sample(llama_sampling_context, ctx);
        if (id == llama_token_eos()) break;

        string token_str = llama_token_to_piece(ctx, id);
        printf("%s", token_str.c_str());
        fflush(stdout);

        embd_gen.push_back(id);
        llama_eval(ctx, embd_gen.data(), embd_gen.size(), n_past, params.n_threads);
        n_past += embd_gen.size();
        embd_gen.clear();
    }

    // 7. 释放资源
    llama_free(ctx);
    llama_free_model(model);
    return 0;
}

数学计算流程

1. 模型架构基础

Llama 的基础模型架构是 Transformer。相比基础 Transformer，Llama 做了以下关键优化：

• RMSNorm: 作为归一化函数，替代 LayerNorm，减少计算开销。
• SwiGLU: 激活函数，结合了 Swish 和 Gating 机制，提升表达能力。
• RoPE: 旋转位置编码，使模型具备外推能力，无需额外绝对位置编码。

LLM 的核心是 Attention 计算。Attention 计算每个 token 相对其他 token 的重要程度，结果是一组权重向量。 公式：$Attention(Q,K,V) = softmax(\frac{QK^T}{\sqrt{d_k}})V$

2. 算子定义

在机器学习中，算子（Operator）通常指执行特定数学运算的函数。对象是张量（Tensor）。 Llama.cpp 通过 ggml_op 枚举定义了底层算子：

enum ggml_op {
    GGML_OP_NONE = 0,
    GGML_OP_DUP,          // 复制
    GGML_OP_ADD,          // 加法
    GGML_OP_MUL,          // 乘法
    GGML_OP_RMS_NORM,     // RMS 归一化
    GGML_OP_ROPE,         // 旋转位置编码
    GGML_OP_SOFT_MAX,     // Softmax
    GGML_OP_FLASH_ATTN,   // Flash Attention 优化
    GGML_OP_MUL_MAT,      // 矩阵乘法
    // ... 更多算子
};

3. Attention 计算与 CUDA 实现

CUDA 是 LLM 计算中最常采用的平台。Llama.cpp 的所有 CUDA 核函数实现在 ggml-cuda.cu 中。

算法流程拆分：

1. Q*K 矩阵乘法 (MatMul)

   • 计算 Query 和 Key 的点积。
   • CUDA 算子：mul_mat_p021_f16_f32
   • 优化点：利用 Shared Memory 减少 Global Memory 访问。

2. 缩放 (Scale)

   • 除以 $\sqrt{d_k}$ 防止梯度消失。
   • CUDA 算子：scale_f32

3. Masking

   • 掩码操作，确保因果性（Decoder 只能看到前面的 token）。
   • CUDA 算子：diag_mask_inf_f32
   • 逻辑：将未来位置的分数设为负无穷。

4. Softmax

   • 将分数转化为概率分布。
   • CUDA 算子：soft_max_f32

5. V*MatMul

   • 加权求和 Value 矩阵。
   • CUDA 算子：mul_mat_vec_nc_f16_f32

工程优化策略

LLAMA.cpp 的目标是在资源受限的环境中高效运行 LLM。

1. 硬件后端优化

通过宏定义切换不同的计算后端：

在 llama_graph_compute() 中，系统会根据后端选择调用对应的算子实现，例如 CUDA 版本会跳过 CPU 计算直接调用 GPU Kernel。

2. 算法级优化

• LoRA (Low-Rank Adaptation)： 一种微调技术，冻结预训练模型权重，仅训练低秩分解矩阵。大幅减少计算资源和内存需求，适合垂直领域适配。

• KV Cache 管理： 缓存 Attention 计算中产生的 Key 和 Value 张量。随着生成长度增加，KV Cache 占用显存线性增长。优化策略包括分页注意力（Paged Attention）或动态回收未使用的 Cache。

• 量化 (Quantization)： 将浮点数（如 FP32）转换为低精度表示（如 INT8, INT4）。

  • FP16: 标准精度，显存占用高。
  • INT8: 平衡性能与精度。
  • INT4 (GGUF): 极致压缩，单卡可运行更大参数模型。 量化在不显著影响模型性能的情况下，显著降低内存占用和计算需求。

3. 显存估算

推理过程需要的显存主要由模型权重和 KV Cache 组成。

以 Llama 7B 模型为例：

• 数据类型：FP16 (2 Bytes)
• Hidden Dim: 4096
• Layers: 32
• Context Length: 1024 tokens

KV Cache 显存计算： $$ \text{Memory} = \text{FP16} \times \text{hidden_dim} \times K,V \times \text{Layers} \times \text{context_length} $$ $$ = 2 \times 4096 \times 2 \times 32 \times 1024 \approx 512 \text{MB} $$

如果输入有 1024 个 token，仅 KV Cache 就需要约 512MB 显存。加上模型权重本身（7B * 2Bytes ≈ 14GB），总显存需求约为 14.5GB。若使用 INT4 量化，模型权重可降至约 4GB，极大降低了部署门槛。

总结

LLM 推理端的实现涉及复杂的系统工程，从底层的算子优化到上层的业务逻辑封装。Llama.cpp 通过 C++ 实现和灵活的硬件后端支持，使得大模型能够在个人电脑甚至嵌入式设备上运行。理解其工作流程、数学原理及优化手段，对于开发者进行模型部署和性能调优至关重要。