C++ 生成式 AI 入门实战：从零构建你的第一个文本生成模型

1次阅读

没有评论

共计 3236 个字符，预计需要花费 9 分钟才能阅读完成。

最近几年生成式 AI 火爆全球，但大多数教程都集中在 Python 生态。作为 C ++ 开发者，你可能面临这些痛点：

Python 代码难以集成到现有 C ++ 项目中
生产环境需要更高的性能和更低的内存占用
缺乏针对 C ++ 的完整生成式 AI 教学资源

其实 C ++ 在 AI 推理阶段有独特优势：内存控制精准、多线程支持完善、部署便捷。本文将用 LibTorch 带你快速入门。

对比主流方案：

TensorFlow C++ API：文档陈旧，构建系统复杂
ONNX Runtime：需要额外转换模型，调试困难
LibTorch：PyTorch 官方 C ++ 前端，特性同步更新

LibTorch 的优势很明显：

直接加载 PyTorch 训练的模型（.pt 文件）
完整的 Autograd 支持
内存管理接口与 STL 风格一致

安装只需下载预编译包（以 Linux 为例）：

wget https://download.pytorch.org/libtorch/cpu/libtorch-cxx11-abi-shared-with-deps-2.0.0%2Bcpu.zip
unzip libtorch*.zip
export Torch_DIR=$(pwd)/libtorch

我们使用简化版 GPT-2：

6 层 Transformer 解码器
隐藏层维度 512
注意力头数 8

模型结构示意图（代码实现）：

struct GPT2Impl : torch::nn::Module {
  torch::nn::Embedding word_embedding;
  std::vector<TransformerBlock> blocks;
  torch::nn::Linear lm_head;

  explicit GPT2Impl(int vocab_size) 
    : word_embedding(register_module("we", torch::nn::Embedding(vocab_size, 512))),
      lm_head(register_module("head", torch::nn::Linear(512, vocab_size))) {for (int i = 0; i < 6; ++i) {blocks.push_back(register_module("block" + std::to_string(i), 
                      TransformerBlock(512, 8)));
    }
  }
  // 前向传播实现...
};

分词处理 ：

std::vector<int> tokenize(const std::string& text) {
  // 使用 BPE 分词器（实际项目建议用现成实现）std::unordered_map<std::string, int> vocab = load_vocab("vocab.txt");
  std::vector<int> tokens;
  size_t pos = 0;
  while (pos < text.length()) {
    // 最长匹配原则查找 token
    for (int len = std::min(text.length()-pos, MAX_TOKEN_LEN); len>=1; --len) {auto it = vocab.find(text.substr(pos, len));
      if (it != vocab.end()) {tokens.push_back(it->second);
        pos += len;
        break;
      }
    }
  }
  return tokens;
}

批次生成 （带 Padding 处理）：

torch::Tensor batchify(const std::vector<std::vector<int>>& sequences) {
  int max_len = 0;
  for (const auto& seq : sequences) {max_len = std::max(max_len, (int)seq.size());
  }

  auto options = torch::TensorOptions().dtype(torch::kInt64);
  torch::Tensor batch = torch::full({ (int)sequences.size(), max_len}, 
    PAD_TOKEN_ID, 
    options);

  for (int i = 0; i < sequences.size(); ++i) {batch[i].slice(0, 0, sequences[i].size()) = 
      torch::from_blob(sequences[i].data(), sequences[i].size(), options).clone();}
  return batch;
}

#include <torch/script.h>

void generate_text(const std::string& prompt) {
  // 加载模型（RAII 风格）torch::jit::script::Module model;
  try {model = torch::jit::load("gpt2.pt");
    model.eval();} catch (const c10::Error& e) {std::cerr << "加载模型失败:" << e.what() << std::endl;
    return;
  }

  // 准备输入
  auto tokens = tokenize(prompt);
  torch::Tensor input = torch::tensor(tokens).unsqueeze(0);

  // 生成循环
  for (int i = 0; i < 100; ++i) { // 最多生成 100 个 token
    auto outputs = model.forward({input}).toTensor();
    auto logits = outputs.slice(1, -1, -1).squeeze();

    // 采样下一个 token（top- k 过滤）auto [val, idx] = torch::topk(logits, 5);
    int next_token = idx[torch::randint(5, {1})].item<int>();

    // 更新输入
    input = torch::cat({input, torch::tensor({{next_token}})}, 1);

    // 打印生成结果
    std::cout << decode_token(next_token);
  }
}

torch::NoGradGuard no_grad; // 禁用梯度计算
#pragma omp parallel for
for (int i = 0; i < batch_size; ++i) {model.forward({inputs[i]});
}

# 先使用 Python 量化模型
import torch
model = torch.quantization.quantize_dynamic(model, {torch.nn.Linear}, dtype=torch.qint8)
torch.jit.save(model, "gpt2_quantized.pt")

量化后模型大小减少约 4 倍，推理速度提升 2 - 3 倍。

内存泄漏点 ：