C++实现卷积神经网络：从零开始的深度学习入门指南

1次阅读

没有评论

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

作为系统级语言，C++ 在以下场景展现独特优势：

嵌入式设备部署 ：树莓派等资源受限环境需要轻量级推理框架
高频交易预测 ：微秒级延迟要求必须避开 Python 的 GIL 限制
工业视觉检测 ：产线上实时处理 4K 视频流需要极致优化

Python 生态（PyTorch/TensorFlow）优势：

丰富的预训练模型库
直观的自动微分机制
Jupyter Notebook 快速原型开发

C++ 的差异化价值：

内存控制精细：可手动管理张量生命周期
并行计算潜力：直接调用底层硬件指令
部署友好：编译成独立二进制无需解释器

推荐使用 Eigen 库替代原生数组操作：

#include <Eigen/Dense>
using Matrix = Eigen::MatrixXf;

// 矩阵乘法对比
void benchmark() {Matrix a = Matrix::Random(1024, 1024);
  Matrix b = Matrix::Random(1024, 1024);

  // 原生循环（慢）Matrix c1(a.rows(), b.cols());
  for(int i=0; i<a.rows(); ++i)
    for(int j=0; j<b.cols(); ++j)
      for(int k=0; k<a.cols(); ++k)
        c1(i,j) += a(i,k) * b(k,j);

  // Eigen 优化（快）Matrix c2 = a * b; 
}

前向传播需要考虑 padding 和 stride：

class ConvLayer {
public:
  ConvLayer(int in_channels, int out_channels, 
           int kernel_size, int stride=1, int pad=0) 
    : kernel_(kernel_size, kernel_size, in_channels, out_channels),
      stride_(stride), pad_(pad) {}

  Matrix forward(const Matrix& input) {
    // 输入格式转换：HWCN -> NHWC
    Matrix padded = zero_pad(input, pad_);

    // 滑动窗口计算（简化版）for(int h=0; h<output_height; ++h)
      for(int w=0; w<output_width; ++w)
        for(int c=0; c<out_channels; ++c) {
          auto window = padded.block(h*stride_, w*stride_, 
                                   kernel_size_, kernel_size_);
          output(h,w,c) = (window * kernel_.chip(c,3)).sum();}
    return output;
  }

private:
  Tensor4f kernel_; // 权重张量
  int stride_, pad_;
};

反向传播需实现局部梯度计算：

void backward(const Matrix& grad_output) {
  // 对输入梯度计算
  grad_input_.setZero();
  for(int h=0; h<output_height; ++h)
    for(int w=0; w<output_width; ++w)
      for(int c=0; c<out_channels; ++c) {
        // 卷积核旋转 180 度后做 full 卷积
        grad_input_.block(h*stride_, w*stride_, 
                         kernel_size_, kernel_size_) 
          += kernel_.chip(c,3).reverse() * grad_output(h,w,c);
      }

  // 对权重梯度计算
  for(int i=0; i<kernel_size_; ++i)
    for(int j=0; j<kernel_size_; ++j)
      for(int c=0; c<out_channels; ++c)
        kernel_grad_(i,j,c) = 
          (input_.block(i,j,output_height,output_width) 
           * grad_output.chip(c,3)).sum();}

以 ReLU 激活函数为例展示微分链传递：

class ReLU {
public:
  Matrix forward(const Matrix& x) {mask_ = (x.array() > 0).cast<float>();
    return x.cwiseMax(0); 
  }

  Matrix backward(const Matrix& grad) {return grad.cwiseProduct(mask_); // 逐元素乘法
  }

private:
  Matrix mask_; // 记录正向传播时的激活状态
};

MNIST 分类网络搭建示例：

class CNN {
public:
  CNN() : 
    conv1(1, 16, 5, 1, 2),  // 16 个 5x5 卷积核
    pool1(2, 2),            // 2x2 最大池化
    fc1(16*14*14, 128),
    fc2(128, 10) {}

  Matrix forward(const Matrix& x) {auto out = conv1.forward(x);
    out = pool1.forward(out);
    out = relu1.forward(out);
    out = out.reshaped(16*14*14, 1); // 展平
    out = fc1.forward(out);
    out = relu2.forward(out);
    return softmax(fc2.forward(out));
  }

  void train(const Matrix& x, int label) {
    // 前向传播
    Matrix pred = forward(x);

    // 计算交叉熵损失
    float loss = -log(pred(label));

    // 反向传播
    Matrix grad = Matrix::Zero(10, 1);
    grad(label) = -1 / pred(label);

    grad = fc2.backward(grad);
    grad = relu2.backward(grad);
    grad = fc1.backward(grad);
    grad = grad.reshaped(16, 14, 14);
    grad = pool1.backward(grad);
    grad = relu1.backward(grad);
    conv1.backward(grad);

    // 参数更新（SGD 优化器）conv1.update(0.01);
    fc1.update(0.01);
    fc2.update(0.01);
  }
};

避免频繁申请释放内存：

class TensorPool {
public:
  Matrix acquire(int rows, int cols) {auto it = std::find_if(pool_.begin(), pool_.end(),
      [&](const Matrix& m) {return m.rows()==rows && m.cols()==cols;});

    if(it != pool_.end()) {
      Matrix m = *it;
      pool_.erase(it);
      return m;
    }
    return Matrix(rows, cols);
  }

  void release(Matrix&& m) {m.setZero();
    pool_.push_back(std::move(m));
  }

private:
  std::vector<Matrix> pool_;
};

使用 Eigen 的向量化指令：

// 编译时启用 AVX2 指令集
#define EIGEN_VECTORIZE_AVX2

// 手动展开循环
void matmul_fast(const Matrix& a, const Matrix& b, Matrix& c) {
  Eigen::internal::gemm_blocked_space<float> workspace;
  Eigen::internal::general_matrix_matrix_product<
    Eigen::RowMajor, Eigen::ColMajor, false, false>
    ::run(a.rows(), b.cols(), a.cols(), 
          a.data(), a.cols(), 
          b.data(), b.cols(), 
          c.data(), c.cols(), 
          1.0, workspace);
}

采用梯度裁剪策略：

void clip_gradients(float max_norm) {
  float total_norm = 0;
  for(auto& param : parameters_)
    total_norm += param.grad.squaredNorm();
  total_norm = sqrt(total_norm);

  if(total_norm > max_norm) {float scale = max_norm / (total_norm + 1e-6);
    for(auto& param : parameters_)
      param.grad *= scale;
  }
}

使用 Log-Sum-Exp 技巧优化 softmax：

Matrix stable_softmax(const Matrix& x) {float max_val = x.maxCoeff();
  Matrix exp_x = (x.array() - max_val).exp();
  float sum_exp = exp_x.sum();
  return exp_x / sum_exp;
}

未来可通过以下路径升级：

使用 CUDA 重写核心算子
集成 cuBLAS 加速矩阵运算
采用异步流水线隐藏数据传输延迟

一个简单的 CUDA 卷积示例：

__global__ void conv_kernel(float* input, float* kernel, 
                           float* output, int width) {
  int row = blockIdx.y * blockDim.y + threadIdx.y;
  int col = blockIdx.x * blockDim.x + threadIdx.x;

  float sum = 0;
  for(int kh = 0; kh < KERNEL_SIZE; ++kh)
    for(int kw = 0; kw < KERNEL_SIZE; ++kw)
      sum += input[(row+kh)*width + (col+kw)] 
             * kernel[kh*KERNEL_SIZE + kw];

  output[row*width + col] = sum;
}

对于刚接触深度学习的 C ++ 开发者，建议分阶段实施：