C++实现反向传播：从零构建神经网络训练核心

1次阅读

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

反向传播的本质是计算图上应用链式法则的梯度累积过程。以一个简单的 3 层全连接网络为例：

前向计算图构建

// 前向传播示例（隐藏层使用 ReLU）MatrixXd h1 = (x * W1).cwiseMax(0); // 输入层→隐藏层 1
MatrixXd h2 = (h1 * W2).cwiseMax(0); // 隐藏层 1→隐藏层 2
MatrixXd y_hat = h2 * W3;            // 隐藏层 2→输出层

链式法则的 C ++ 实现
输出层梯度：$\frac{\partial L}{\partial W_3} = h_2^T \cdot \frac{\partial L}{\partial y}$
隐藏层梯度：$\frac{\partial L}{\partial h_1} = \frac{\partial L}{\partial h_2} \odot \text{ReLU}'(h_1W_2)$

// 反向传播核心代码段
MatrixXd grad_y = y_hat - y_true; // 损失函数梯度
MatrixXd grad_W3 = h2.transpose() * grad_y;

MatrixXd relu_mask = (h1.array() > 0).cast<double>();
MatrixXd grad_h1 = (grad_h2 * W2.transpose()).cwiseProduct(relu_mask);

// 使用 Eigen 的广播机制实现 softmax 梯度
MatrixXd softmax_grad(const MatrixXd& s) {MatrixXd diag = s.asDiagonal();
    return diag - s.transpose() * s;}

// 手动循环 + 内存预分配（适合固定维度场景）void naive_softmax_grad(double* dst, const double* src, int dim) {double* tmp = new double[dim*dim]; // 预分配临时内存
    for(int i=0; i<dim; ++i) {for(int j=0; j<dim; ++j) {tmp[i*dim+j] = (i==j) ? src[i]*(1-src[j]) : -src[i]*src[j];
        }
    }
    memcpy(dst, tmp, dim*dim*sizeof(double));
    delete[] tmp;}

class NeuralNetwork {
public:
    void backward(const MatrixXd& x, const MatrixXd& y_true) {
        // 动态维度校验（示例）assert(x.cols() == W1.rows() && "输入维度不匹配");

        // 前向计算缓存
        MatrixXd h1 = (x * W1).cwiseMax(0);
        MatrixXd h2 = (h1 * W2).cwiseMax(0);
        MatrixXd y_hat = softmax(h2 * W3);

        // 误差反向传播
        MatrixXd grad_y = y_hat - y_true;

        // 权重梯度计算（注意转置顺序）grad_W3 = h2.transpose() * grad_y;
        MatrixXd grad_h2 = grad_y * W3.transpose();

        // 处理 ReLU 导数
        MatrixXd mask2 = (h2.array() > 0).cast<double>();
        grad_W2 = h1.transpose() * grad_h2.cwiseProduct(mask2);

        MatrixXd grad_h1 = grad_h2 * W2.transpose();
        MatrixXd mask1 = (h1.array() > 0).cast<double>();
        grad_W1 = x.transpose() * grad_h1.cwiseProduct(mask1);
    }

private:
    MatrixXd W1, W2, W3;
    MatrixXd grad_W1, grad_W2, grad_W3;
};

梯度爆炸 ：检查权重更新幅度，添加梯度裁剪

double max_grad = 1.0;
grad_W3 = grad_W3.unaryExpr([&](double x) {return std::min(max_grad, std::max(-max_grad, x)); 
});

梯度消失 ：监控各层梯度范数，考虑使用 LeakyReLU

// LeakyReLU 实现示例
auto leaky_relu = [](double x) {return x > 0 ? x : 0.01*x;};

log-sum-exp 技巧 ：

// softmax 的数值稳定实现
MatrixXd stable_softmax(const MatrixXd& x) {MatrixXd exp_x = (x.array() - x.maxCoeff()).exp();
    return exp_x.array() / exp_x.sum();
}