使用 C++ 在深度学习中的应用：如何通过 C++20 构建高效神经网络
深度学习已经成为现代人工智能的核心技术，在图像识别、自然语言处理、语音识别等多个领域广泛应用。尽管 Python 因其简便易用和强大的深度学习框架（如 TensorFlow 和 PyTorch）而在这一领域占据主导地位，但 C++ 作为一门高性能语言，仍然在许多高效计算场景中有着不可忽视的优势。
在这篇文章中，我们将介绍如何使用 C++20 构建高效的神经网络。通过结合现代 C++ 特性，我们不仅能提升模型的计算效率，还能充分发挥 C++ 在性能优化方面的优势。
目录
1. C++ 神经网络设计基础
1.1 神经网络的基本结构
1.2 单隐层神经网络的实现
2. 使用现代 C++ 特性优化
2.1 智能指针与资源管理
2.2 并行计算加速
2.2.1 使用 std::for_each 实现并行计算
2.2.2 代码解析
2.2.3 性能提升
2.2.4 注意事项
3. 总结
1. C++ 神经网络设计基础
1.1 神经网络的基本结构
神经网络的核心结构通常包括输入层、隐藏层和输出层。每一层包含若干个神经元，数据通过前向传播（Forward Propagation）逐层传递，在每一层进行加权求和和激活函数处理，最终输出预测结果。通过反向传播（Backpropagation），我们根据预测结果与实际标签的误差来调整网络中的权重和偏置。
1.2 单隐层神经网络的实现
我们首先从最简单的单隐层神经网络开始，实现一个输入层、隐藏层和输出层的基本结构，并采用 Sigmoid 激活函数。
#include <iostream>
#include <vector>
#include <cmath>
#include <cassert>
// Tensor 类：表示矩阵或张量
class Tensor {
public:
Tensor(int rows, int cols) : rows_(rows), cols_(cols) {
data_ = std::vector<std::vector<float>>(rows, std::vector<float>(cols, 0.0f));
}
float& at(int row, int col) { return data_[row][col]; }
float at(int row, int col) const { return data_[row][col]; }
int getRows() const { return rows_; }
int getCols() const { return cols_; }
void randomize() {
for (int i = 0; i < rows_; ++i) {
for (int j = 0; j < cols_; ++j) {
data_[i][j] = (rand() % 100) / 100.0f; // 生成 0 到 1 之间的随机数
}
}
}
private:
int rows_, cols_;
std::vector<std::vector<float>> data_;
};
// 矩阵乘法
Tensor matmul(const Tensor& A, const Tensor& B) {
assert(A.getCols() == B.getRows());
Tensor result(A.getRows(), B.getCols());
for (int i = 0; i < A.getRows(); ++i) {
for (int j = 0; j < B.getCols(); ++j) {
float sum = 0.0f;
for (int k = 0; k < A.getCols(); ++k) {
sum += A.at(i, k) * B.at(k, j);
}
result.at(i, j) = sum;
}
}
return result;
}
// 激活函数：Sigmoid
float sigmoid(float x) {
return 1.0f / (1.0f + exp(-x));
}
// Sigmoid 的导数
float sigmoid_derivative(float x) {
return x * (1.0f - x);
}
// 神经网络类
class NeuralNetwork {
public:
NeuralNetwork(int input_size, int hidden_size, int output_size) {
weights_input_hidden = Tensor(input_size, hidden_size);
weights_input_hidden.randomize();
bias_hidden = Tensor(1, hidden_size);
bias_hidden.randomize();
weights_hidden_output = Tensor(hidden_size, output_size);
weights_hidden_output.randomize();
bias_output = Tensor(1, output_size);
bias_output.randomize();
}
Tensor forward(const Tensor& input) {
// 输入层到隐藏层
Tensor hidden = matmul(input, weights_input_hidden);
add_bias(hidden, bias_hidden);
apply_sigmoid(hidden);
// 隐藏层到输出层
Tensor output = matmul(hidden, weights_hidden_output);
add_bias(output, bias_output);
apply_sigmoid(output);
return output;
}
void backward(const Tensor& input, const Tensor& target, float learning_rate) {
Tensor output = forward(input);
Tensor output_error = compute_error(output, target);
// 计算隐藏层误差
Tensor hidden_error = matmul(output_error, transpose(weights_hidden_output));
for (int i = 0; i < hidden_error.getRows(); ++i) {
for (int j = 0; j < hidden_error.getCols(); ++j) {
hidden_error.at(i, j) *= sigmoid_derivative(output.at(i, j));
}
}
// 更新权重和偏置
update_weights(weights_hidden_output, output_error, learning_rate);
update_bias(bias_output, output_error, learning_rate);
update_weights(weights_input_hidden, hidden_error, learning_rate);
update_bias(bias_hidden, hidden_error, learning_rate);
}
private:
Tensor weights_input_hidden, weights_hidden_output;
Tensor bias_hidden, bias_output;
// 辅助函数：应用 Sigmoid 激活函数
void apply_sigmoid(Tensor& tensor) {
for (int i = 0; i < tensor.getRows(); ++i) {
for (int j = 0; j < tensor.getCols(); ++j) {
tensor.at(i, j) = sigmoid(tensor.at(i, j));
}
}
}
// 辅助函数：添加偏置
void add_bias(Tensor& tensor, const Tensor& bias) {
for (int i = 0; i < tensor.getRows(); ++i) {
for (int j = 0; j < tensor.getCols(); ++j) {
tensor.at(i, j) += bias.at(0, j);
}
}
}
// 计算误差
Tensor compute_error(const Tensor& output, const Tensor& target) {
Tensor error(output.getRows(), output.getCols());
for (int i = 0; i < output.getRows(); ++i) {
for (int j = 0; j < output.getCols(); ++j) {
error.at(i, j) = output.at(i, j) - target.at(i, j); // MSE
}
}
return error;
}
// 转置矩阵
Tensor transpose(const Tensor& tensor) {
Tensor transposed(tensor.getCols(), tensor.getRows());
for (int i = 0; i < tensor.getRows(); ++i) {
for (int j = 0; j < tensor.getCols(); ++j) {
transposed.at(j, i) = tensor.at(i, j);
}
}
return transposed;
}
// 更新权重
void update_weights(Tensor& weights, const Tensor& error, float learning_rate) {
for (int i = 0; i < weights.getRows(); ++i) {
for (int j = 0; j < weights.getCols(); ++j) {
weights.at(i, j) -= learning_rate * error.at(i, j);
}
}
}
// 更新偏置
void update_bias(Tensor& bias, const Tensor& error, float learning_rate) {
for (int i = 0; i < bias.getCols(); ++i) {
bias.at(0, i) -= learning_rate * error.at(0, i);
}
}
};
int main() {
NeuralNetwork nn(2, 3, 1); // 输入层2个节点，隐藏层3个节点，输出层1个节点
// 训练数据：XOR 问题
Tensor inputs(4, 2);
inputs.at(0, 0) = 0.0f; inputs.at(0, 1) = 0.0f;
inputs.at(1, 0) = 0.0f; inputs.at(1, 1) = 1.0f;
inputs.at(2, 0) = 1.0f; inputs.at(2, 1) = 0.0f;
inputs.at(3, 0) = 1.0f; inputs.at(3, 1) = 1.0f;
Tensor targets(4, 1);
targets.at(0, 0) = 0.0f;
targets.at(1, 0) = 1.0f;
targets.at(2, 0) = 1.0f;
targets.at(3, 0) = 0.0f;
// 训练神经网络并打印误差
for (int epoch = 0; epoch < 10000; ++epoch) {
nn.backward(inputs, targets, 0.1f);
if (epoch % 1000 == 0) {
Tensor result = nn.forward(inputs);
float error = 0.0f;
for (int i = 0; i < result.getRows(); ++i) {
error += fabs(result.at(i, 0) - targets.at(i, 0));
}
std::cout << "Epoch " << epoch << " - Error: " << error << std::endl;
}
}
// 测试结果
std::cout << "\nPredictions after training:" << std::endl;
Tensor result = nn.forward(inputs);
for (int i = 0; i < result.getRows(); ++i) {
std::cout << "Input: (" << inputs.at(i, 0) << ", " << inputs.at(i, 1) << ") -> Predicted Output: "
<< result.at(i, 0) << " (Expected: " << targets.at(i, 0) << ")" << std::endl;
}
return 0;
}
2. 使用现代 C++ 特性优化
2.1 智能指针与资源管理
C++ 引入了智能指针（如 std::unique_ptr 和 std::shared_ptr），这些智能指针能够自动管理内存，减少内存泄漏的风险。在深度学习框架中，动态分配的内存管理至关重要，使用智能指针可以提升代码的安全性和可维护性。
#include <memory>
class NeuralNetwork {
public:
NeuralNetwork() {
layers.push_back(std::make_unique<SigmoidLayer>(2, 3));
layers.push_back(std::make_unique<SigmoidLayer>(3, 1));
}
Tensor forward(const Tensor& input) {
Tensor output = input;
for (const auto& layer : layers) {
output = layer->forward(output);
}
return output;
}
void backward(const Tensor& input, const Tensor& target) {
Tensor output = forward(input);
Tensor error = output;
for (int i = layers.size() - 1; i >= 0; --i) {
layers[i]->backward(input, error);
error = layers[i]->error;
}
}
private:
std::vector<std::unique_ptr<Layer>> layers;
};
2.2 并行计算加速
在大规模神经网络训练和推理中，矩阵乘法是计算瓶颈之一。C++20 引入了 std::execution 标准库，提供了便捷的并行计算支持，使得我们能够通过并行化矩阵计算来加速深度学习模型的训练。通过将计算任务分配给多个处理器核心，可以显著提升计算速度，尤其是当数据量非常庞大的时候。
std::execution::par 是 C++20 并行算法的一部分，可以通过它使得某些算法（例如 std::for_each）并行执行，从而提高性能。通过这一特性，我们可以轻松地将矩阵乘法的计算并行化，实现显著的加速。
2.2.1 使用 std::for_each 实现并行计算
std::for_each 是一个算法，用于对指定范围的每个元素执行操作。在 C++20 中，我们可以指定 std::execution::par 来告知编译器我们希望对该范围内的元素进行并行处理。
为了实现并行矩阵乘法，我们将 std::for_each 应用于矩阵 result 的每个元素，在计算每个元素时，我们将其对应的行和列进行点积操作，从而计算出矩阵乘法的结果。
下面是一个细化的并行矩阵乘法实现：
#include <execution>
#include <vector>
#include <iostream>
class Tensor {
public:
Tensor(int rows, int cols) : rows_(rows), cols_(cols) {
data_ = std::vector<std::vector<float>>(rows, std::vector<float>(cols, 0.0f));
}
float& at(int row, int col) { return data_[row][col]; }
float at(int row, int col) const { return data_[row][col]; }
int getRows() const { return rows_; }
int getCols() const { return cols_; }
auto begin() { return data_.begin(); }
auto end() { return data_.end(); }
private:
int rows_, cols_;
std::vector<std::vector<float>> data_;
};
// 并行矩阵乘法函数
void parallel_matrix_multiplication(const Tensor& A, const Tensor& B, Tensor& result) {
int rowsA = A.getRows();
int colsA = A.getCols();
int rowsB = B.getRows();
int colsB = B.getCols();
if (colsA != rowsB) {
std::cerr << "Matrix dimensions do not match for multiplication!" << std::endl;
return;
}
// 使用并行执行计算每个结果元素
std::for_each(std::execution::par, result.begin(), result.end(), [&](auto& element) {
int row = &element - &result.at(0, 0); // 当前元素所在的行
int col = &element - &result.at(0, 0); // 当前元素所在的列
// 计算 A 行与 B 列的点积
float sum = 0.0f;
for (int k = 0; k < colsA; ++k) {
sum += A.at(row, k) * B.at(k, col);
}
result.at(row, col) = sum;
});
}
int main() {
Tensor A(2, 3); // A 为 2x3 矩阵
Tensor B(3, 2); // B 为 3x2 矩阵
Tensor C(2, 2); // 结果矩阵 C 为 2x2 矩阵
// 初始化矩阵 A 和 B
A.at(0, 0) = 1.0f; A.at(0, 1) = 2.0f; A.at(0, 2) = 3.0f;
A.at(1, 0) = 4.0f; A.at(1, 1) = 5.0f; A.at(1, 2) = 6.0f;
B.at(0, 0) = 7.0f; B.at(0, 1) = 8.0f;
B.at(1, 0) = 9.0f; B.at(1, 1) = 10.0f;
B.at(2, 0) = 11.0f; B.at(2, 1) = 12.0f;
// 执行并行矩阵乘法
parallel_matrix_multiplication(A, B, C);
// 打印结果矩阵
std::cout << "Matrix C (Result of A * B):" << std::endl;
for (int i = 0; i < C.getRows(); ++i) {
for (int j = 0; j < C.getCols(); ++j) {
std::cout << C.at(i, j) << " ";
}
std::cout << std::endl;
}
return 0;
}
2.2.2 代码解析
- 矩阵表示：我们使用
Tensor类来表示矩阵。矩阵是一个二维数组，我们为每个矩阵元素提供了at()方法来访问其值。 - 并行化矩阵计算：在
parallel_matrix_multiplication函数中，我们使用了std::for_each(std::execution::par, ...)来并行计算result矩阵的每个元素。对于每个元素，我们计算其对应的行和列的点积，并将结果存储到result矩阵中。 - 元素定位：通过
&element - &result.at(0, 0)，我们找到了当前元素的行和列索引。这样每个线程都能够独立处理一个矩阵元素，而不会产生数据竞争。 - 矩阵维度检查：在进行矩阵乘法之前，我们检查了矩阵的维度是否符合乘法要求（即
A的列数等于B的行数）。
2.2.3 性能提升
使用 std::execution::par 可以让我们充分利用现代 CPU 的多核架构。在多核处理器上，每个矩阵元素的计算任务都被分配到不同的线程上，从而加速了矩阵乘法的计算。当矩阵的规模很大时，这种并行化带来的加速效果更加明显。
2.2.4 注意事项
- 线程安全：由于每个线程处理矩阵中的不同元素，因此不会发生数据竞争，保证了线程安全。
- 负载均衡：并行算法的效果依赖于负载的均衡。在大规模矩阵计算中，
std::for_each会根据 CPU 核心的数量自动分配任务，从而提升计算效率。
3. 总结
本文通过 C++20 展示了如何从头开始构建一个高效的神经网络，并结合现代 C++ 特性进行优化。在深度学习应用中，C++ 能够提供更高的性能和灵活性，尤其适用于对计算效率要求较高的场景。通过适当使用智能指针、并行计算等技术，我们能够在 C++ 中实现高效的深度学习框架，充分发挥其性能优势。
希望本文能为你提供一个了解如何在 C++ 中实现神经网络的起点，并为你在构建高效深度学习模型的过程中提供有益的帮助。