用 C++ 玩转字符级 Transformer 语言模型：从原理到实现

日常刷到的 AI 续写故事、自动写文案，背后都是语言模型在发力。很多人觉得这类模型是 Python 的“专属领域”，但其实用 C++ 也能从零搭建一个基于 Transformer 的字符级语言模型——既能吃透底层原理，又能体验更贴近硬件的高效实现。今天就用大白话聊透：从核心原理到代码落地，怎么用 C++ + LibTorch 玩转这个模型。

程序猿编码

857人浏览 · 2025-12-09 22:31:49

程序猿编码 · 2025-12-09 22:31:49 发布

一、先搞懂：我们要做的到底是什么？

1. 字符级语言模型：最小单位是“单个字符”

语言模型分两种常见粒度：词级和字符级。

词级模型：把“苹果”“开心”这类完整的词当基本单位，比如 ChatGPT 底层就是词/子词级；
字符级模型：把“苹”“果”“开”“心”拆成单个字符，每个字符就是最小单位。

字符级模型的好处特别适合入门：词汇表极小（比如一篇中文小说的字符集可能就几百个）、适配小众文本（比如冷门方言、自定义文本），虽然序列长度更长，但能让我们聚焦核心原理，不用纠结复杂的分词问题。

2. Transformer：为啥能让模型“读懂上下文”？

字符级模型的核心是 Transformer 架构，它的灵魂是“自注意力机制”——说白了，就是让模型读文本时，每个字符都能“回头看”前面的字符，判断哪些和自己有关，给不同字符分配不同的“关注度”。

比如看到句子“她拿起水杯，把它放在桌上”，模型能通过注意力机制知道“它”指的是“水杯”，而不是“她”；再配合前馈网络做计算、残差连接保稳定，最终让模型能根据上下文预测下一个字符。

二、核心知识点：Transformer 里的“关键部件”（大白话版）

想搭好模型，先搞懂这几个核心概念，不用记公式，理解作用就行：

部件	大白话作用
自注意力机制	让每个字符“看上下文找关系”，比如“它”对应“水杯”，给相关字符高权重
多头注意力	分多个“视角”找关系（比如一个看语法、一个看语义），结果合并，看得更全面
残差连接	模型层数深了容易“学不动”，残差就是“走捷径”：把输入直接加到输出上，防止梯度消失
层归一化	把每层输出调整到合适范围，比如把数值限定在±1之间，让训练更稳定
前馈网络（FeedForward）	注意力负责“找关系”，前馈网络负责“加工关系”，相当于先找关联，再做推理
位置编码	Transformer 本身不记顺序，字符级模型里“我吃苹果”和“苹果吃我”天差地别，位置编码就是给每个字符加“位置标签”，让模型知道顺序

三、设计思路：为啥选 C++ + LibTorch？

很多人用 Python 做深度学习，是因为封装好、上手快，但我们选 C++ 有两个核心原因：

性能优势：C++ 更贴近底层，速度快、资源占用低，适合需要部署到嵌入式设备、高性能服务器的场景；
LibTorch 兜底：LibTorch 是 PyTorch 的 C++ 接口，既能用上 PyTorch 的张量计算、自动求导等核心功能，又能享受 C++ 的效率，不用从零写矩阵运算。

我们的设计目标很简单：搭一个轻量的字符级 Transformer，能实现“给开头续写文本”，核心流程分四步：

数据预处理：把文本转成模型能计算的数字；
模型架构：按 Transformer 核心结构搭积木；
训练：让模型从文本里学规律；
生成：用训练好的模型续写文本。

四、代码实现流程：从文本到生成（附简易架构图）

先看整体架构（文字版流程图），像搭积木一样一步步来：

【数据层】
文本文件 → 字符-数字映射（stoi/itos）→ 文本编码（转数字张量）→ 拆分训练/验证集 → 批量切分（按固定长度分段）
   ↓
【模型层】
嵌入层（字符向量+位置向量）→ 多个Transformer块（层归一化→多头注意力→残差→层归一化→前馈网络→残差）→ 最终层归一化 → 输出层（转字符概率）
   ↓
【训练层】
批量取数据 → 前向计算损失 → 优化器更新参数 → 定期验证（看训练/验证损失）
   ↓
【生成层】
输入初始字符编码 → 模型预测下一个字符概率 → 采样选字符 → 拼接 → 重复生成 → 解码回文本

...
int main() {
    try {
        std::string filename = "Neopolitan.txt"; 
        
        // 加载并准备训练数据
        TrainingData data = load_training_data(filename);
        
        // 打印基本统计信息
        std::cout << "Dataset: " << data.text.length() << " characters, " << data.vocab_size << " unique tokens" << std::endl;
        
        // 拆分为训练集和验证集
        auto [train_data, val_data] = split_data(data.encoded_text, 0.9);
        
        std::cout << "Train/val split: " << train_data.size(0) << "/" << val_data.size(0) << " tokens" << std::endl;
        
        // 从训练数据中获取批次数据的示例
        auto [x, y] = get_batches(train_data, val_data, batch_size, block_size, "train");
        
        // 从验证数据中获取批次数据的示例
        auto [x_val, y_val] = get_batches(train_data, val_data, batch_size, block_size, "val");
        
        // 创建并测试二元语言模型
        BigramLanguageModel model(data.vocab_size);
        
        // 创建AdamW优化器
        auto optimizer = torch::optim::AdamW(model.parameters(), 
            torch::optim::AdamWOptions(learning_rate));
        
        std::cout << "Model: " << n_layer << " layers, " << n_head << " heads, " << n_embd << " dim" << std::endl;
        std::cout << "Training: " << batch_size << " batch, " << block_size << " context, " << learning_rate << " lr" << std::endl;
        
        // 训练前的初始损失估计
        auto [initial_train_loss, initial_val_loss] = estimate_loss(model, train_data, val_data, 
                                                                   batch_size, block_size, eval_iters);
        std::cout << "Initial loss: " << initial_train_loss << " (train) " << initial_val_loss << " (val)" << std::endl;
        
        // 训练循环
        for (int iter = 0; iter < max_iters; iter++) {
            // 获取一批数据
            auto [x, y] = get_batches(train_data, val_data, batch_size, block_size, "train");
            
            auto loss = model.forward(x, y);
            
            optimizer.zero_grad();
            loss.backward();
            optimizer.step();
            
            if (iter % 100 == 0) {
                std::cout << "iter " << iter << ": loss " << loss.item<float>() << std::endl;
            }
            
            // 在验证集上评估
            if (iter % eval_interval == 0) {
                // 对多个批次进行损失估计，以获得更稳定的评估结果
                auto [avg_train_loss, avg_val_loss] = estimate_loss(model, train_data, val_data, 
                                                                   batch_size, block_size, eval_iters);
                
                std::cout << "iter " << iter << ": train " << avg_train_loss << ", val " << avg_val_loss << std::endl;
            }
        }
        
        std::cout << "Training complete!" << std::endl;
        
        // 使用自定义提示生成测试文本
        std::string custom_prompt = "The story begins with a mysterious letter that arrived";
        std::string generated = generate_with_prompt(model, custom_prompt, data.stoi, data.itos, 200);
        std::cout << "Prompt: \"" << custom_prompt << "\"" << std::endl;
        std::cout << "Generated: \"" << generated << "\"" << std::endl;
        
        // 使用不同的提示生成多个样本
        std::cout << "\n=== Multiple Generation Samples ===" << std::endl;
        
        std::vector<std::string> prompts = {
            "In the quiet town of Naples, where the streets",
            "She opened the door slowly, her heart pounding",
            "The old man sat by the window, watching the",
            "When Elena first met Lila, she knew that",
            "The factory workers gathered in the square, their"
        };
        
        for (int i = 0; i < prompts.size(); i++) {
            std::cout << "\nSample " << (i+1) << ":" << std::endl;
            std::cout << "Prompt: \"" << prompts[i] << "\"" << std::endl;
            
            std::string generated = generate_with_prompt(model, prompts[i], data.stoi, data.itos, 150);
            std::cout << "Generated: \"" << generated << "\"" << std::endl;
        }
        
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
        return 1;
    }
    
    return 0;
}

If you need the complete source code, please add the WeChat number (c17865354792)

下面拆解核心模块：

1. 数据预处理：把文本“翻译”成数字

计算机只认数字，所以第一步要把字符转成数字，核心代码逻辑：

// 读文本文件（比如小说.txt）
std::string text = read_text_file("小说.txt");
// 找出所有不同的字符，给每个字符编个号（比如“我”=0，“的”=1）
auto stoi = create_vocabulary(text);
// 把整段文本转成数字张量（比如“我吃饭”→[0,5,8]）
auto encoded_text = encode_text(text, stoi);
// 拆分训练集（90%）和验证集（10%），防止模型学“偏”
auto [train_data, val_data] = split_data(encoded_text, 0.9);
// 生成批量数据，按256个字符切分，每次取64批训练
auto [x, y] = get_batches(train_data, val_data, 64, 256, "train");

关键作用：验证集用来判断模型有没有“死记硬背”训练集，批量切分是为了让模型一次学一小段，效率更高。

2. 多头注意力：让模型“找字符间的关系”

这是 Transformer 的核心，核心代码逻辑翻译：

// 把字符向量转成Key（键）、Query（查询）、Value（值）——注意力的三个核心
auto k = key(x); auto q = query(x); auto v = value(x);
// 拆成6个头，每个头单独找关系（比如头1看相邻字符，头2看隔一个的字符）
k = k.view({B, T, 6, 64}).transpose(1, 2);
// 计算注意力分数，给相关字符高分，无关字符低分
auto scores = torch::matmul(q, k.transpose(-2, -1)) / sqrt(64);
// 加“掩码”——预测第10个字符时，只能看前9个，不能“作弊看未来”
scores = scores.masked_fill(mask == 0, -1e9);
// 转成概率，乘Value得到注意力输出，再合并所有头的结果
auto att = torch::softmax(scores, -1);
auto out = torch::matmul(att, v);
out = out.transpose(1, 2).contiguous().view({B, T, 384});

关键作用：掩码保证模型“因果性”（只能看过去，不能看未来），多头让模型从多个角度找关系，比单头更全面。

3. Transformer 块：注意力+前馈，加残差保稳定

一个 Transformer 块是“注意力（沟通）+ 前馈（计算）”的组合，核心逻辑：

// 层归一化→注意力→残差（输入直接加输出）
auto x_att = x + sa_head->forward(ln1(x));
// 层归一化→前馈网络→残差
auto x_ffwd = x_att + ffwd->forward(ln2(x_att));

关键作用：残差连接防止模型层数深了“学忘光”，层归一化让数值范围稳定，训练不崩。

4. 训练+生成：让模型学规律，再续写文本

训练逻辑：

// 循环训练5000次，每次算损失、更新参数
for (int iter = 0; iter < 5000; iter++) {
    auto [x, y] = get_batches(train_data, val_data, 64, 256, "train");
    auto loss = model.forward(x, y); // 前向算损失
    optimizer.zero_grad(); // 清空梯度
    loss.backward(); // 反向传播
    optimizer.step(); // 更新参数
}

生成逻辑：

// 给初始字符（比如“在那不勒斯的小巷里”），模型一步步预测下一个字符
std::string prompt = "在那不勒斯的小巷里";
auto prompt_encoded = encode_text(prompt, stoi);
std::string generated = model.generate(prompt_encoded.unsqueeze(0), itos, 200);

关键作用：生成时每次只预测下一个字符，拼接起来就是完整文本；AdamW 优化器是目前最常用的，能让模型学的更快。

五、知识要点+设计领域总结

1. 核心知识要点

字符级模型是入门 Transformer 的最佳载体：粒度最小，不用纠结分词，能聚焦核心架构；
注意力的本质是“加权求和”：给相关字符高权重，无关字符低权重，多头是“多视角加权”；
残差+层归一化是深度模型的“保命符”：没有这两个，模型训练几层就会崩；
C+++LibTorch 是“实验→部署”的桥梁：用 Python 做实验快，用 C++ 部署效率高，LibTorch 打通了两者。

2. 延伸设计领域

自然语言处理（NLP）：字符级模型可用于低资源语言（比如小语种）、文本纠错、自定义文本生成；
高性能计算：C++ 实现的模型可部署到嵌入式设备（比如智能音箱）、边缘服务器，比 Python 省内存、快30%+；
模型轻量化：这个简易 Transformer 是大模型的“缩小版”，理解后能拆解 GPT、LLaMA 等大模型的架构设计；
深度学习工程化：从“Python 写原型”到“C++ 落地”，是工业界深度学习的核心流程。

六、最后聊两句

用 C++ 搭字符级 Transformer，看似复杂，其实拆解开就是“数据处理→模型搭积木→训练→生成”四个步骤。抛开 Python 的“封装便利”，用 C++ 手写一遍，能真正看到：注意力怎么找关系、残差怎么保稳定、位置编码怎么记顺序。

这不仅是一次技术练习，更是理解“AI 怎么生成文本”的最好方式——当你看到模型能根据你给的开头，续写一段通顺的文字时，就能真切感受到：那些看似复杂的 AI 能力，本质都是由这些简单的模块一步步拼出来的。下次想做个自定义的文本生成工具，不妨试试用 C++ 从头搭一个，体验从0到1构建 AI 模型的乐趣。

Welcome to follow WeChat official account【程序猿编码】