当前位置：首页 > news >正文

网站简单设计网站创建免费用户

news 2025/7/27 20:41:06

网站简单设计,网站创建免费用户,个人网站成品,wordpress中调用分类目录文章列表深度学习已经成为现代人工智能的核心技术，在图像识别、自然语言处理、语音识别等多个领域广泛应用。尽管 Python 因其简便易用和强大的深度学习框架（如 TensorFlow 和 PyTorch）而在这一领域占据主导地位，但 C 作为一门高性能语言&…

深度学习已经成为现代人工智能的核心技术，在图像识别、自然语言处理、语音识别等多个领域广泛应用。尽管 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 和 BA.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 的行数）。