使用 C++ 在深度学习中的应用：如何通过 C++20 构建高效神经网络

salsm2025-01-25 14:48

深度学习已经成为现代人工智能的核心技术，在图像识别、自然语言处理、语音识别等多个领域广泛应用。尽管 Python 因其简便易用和强大的深度学习框架（如 TensorFlow 和 PyTorch）而在这一领域占据主导地位，但 C++ 作为一门高性能语言，仍然在许多高效计算场景中有着不可忽视的优势。

在这篇文章中，我们将介绍如何使用 C++20 构建高效的神经网络。通过结合现代 C++ 特性，我们不仅能提升模型的计算效率，还能充分发挥 C++ 在性能优化方面的优势。

目录

[1. C++ 神经网络设计基础](#1. C++ 神经网络设计基础)

[1.1 神经网络的基本结构](#1.1 神经网络的基本结构)

[1.2 单隐层神经网络的实现](#1.2 单隐层神经网络的实现)

[2. 使用现代 C++ 特性优化](#2. 使用现代 C++ 特性优化)

[2.1 智能指针与资源管理](#2.1 智能指针与资源管理)

[2.2 并行计算加速](#2.2 并行计算加速)

[2.2.1 使用 std::for_each 实现并行计算](#2.2.1 使用 std::for_each 实现并行计算)

[2.2.2 代码解析](#2.2.2 代码解析)

[2.2.3 性能提升](#2.2.3 性能提升)

[2.2.4 注意事项](#2.2.4 注意事项)

[3. 总结](#3. 总结)

1. C++ 神经网络设计基础

1.1 神经网络的基本结构

神经网络的核心结构通常包括输入层、隐藏层和输出层。每一层包含若干个神经元，数据通过前向传播（Forward Propagation）逐层传递，在每一层进行加权求和和激活函数处理，最终输出预测结果。通过反向传播（Backpropagation），我们根据预测结果与实际标签的误差来调整网络中的权重和偏置。

1.2 单隐层神经网络的实现

我们首先从最简单的单隐层神经网络开始，实现一个输入层、隐藏层和输出层的基本结构，并采用 Sigmoid 激活函数。

cpp 复制代码 
#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），这些智能指针能够自动管理内存，减少内存泄漏的风险。在深度学习框架中，动态分配的内存管理至关重要，使用智能指针可以提升代码的安全性和可维护性。

cpp 复制代码 
#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 的每个元素，在计算每个元素时，我们将其对应的行和列进行点积操作，从而计算出矩阵乘法的结果。

下面是一个细化的并行矩阵乘法实现：

cpp 复制代码 
#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++ 中实现神经网络的起点，并为你在构建高效深度学习模型的过程中提供有益的帮助。

相关推荐
Zack_Liu1 小时前
深度学习基础模块
人工智能·深度学习
闲看云起2 小时前
Bert：从“读不懂上下文”的AI，到真正理解语言
论文阅读·人工智能·深度学习·语言模型·自然语言处理·bert
信息快讯4 小时前
【机器学习赋能的智能光子学器件系统研究与应用】
人工智能·神经网络·机器学习·光学
IT小哥哥呀5 小时前
基于深度学习的数字图像分类实验与分析
人工智能·深度学习·分类
汉堡go7 小时前
1、机器学习与深度学习
人工智能·深度学习·机器学习
LiJieNiub8 小时前
基于 PyTorch 实现 MNIST 手写数字识别
pytorch·深度学习·学习
chxin140168 小时前
Transformer注意力机制——动手学深度学习10
pytorch·rnn·深度学习·transformer
lljss20208 小时前
5. 神经网络的学习
人工智能·神经网络·学习
jie*8 小时前
小杰深度学习（fourteen）——视觉-经典神经网络——ResNet
人工智能·python·深度学习·神经网络·机器学习·tensorflow·lstm
jie*8 小时前
小杰深度学习（sixteen）——视觉-经典神经网络——MobileNetV2
人工智能·python·深度学习·神经网络·tensorflow·numpy·matplotlib
热门推荐
01两千字总结：Codex 国内如何安装和使用的教程，以及如何设置中文回答02BongoCat - 跨平台键盘猫动画工具03GitHub 镜像站点04UV安装并设置国内源05Linux下V2Ray安装配置指南06GitLab 零基础入门指南：从安装到项目管理全流程07智能库存管理的需求预测模型：从业务痛点到落地代码的完整实践0846个Nano-banana 精选提示词，持续更新中092025羊城杯网络安全大赛 wp10UV 工具安装与国内镜像源配置指南