从零构建神经网络（C++语言神经网络算法入门与实战）

第一步：理解神经网络的基本组成

一个最简单的神经网络包含以下部分：

• 输入层（Input Layer）：接收原始数据
• 隐藏层（Hidden Layer）：进行特征提取和非线性变换
• 输出层（Output Layer）：给出最终预测结果
• 权重（Weights）和偏置（Biases）：可学习参数
• 激活函数（Activation Function）：如Sigmoid、ReLU等，引入非线性

第二步：搭建C++项目结构

我们不需要复杂的框架，只需标准库即可。创建一个名为 NeuralNetwork.cpp 的文件。

第三步：编写核心代码

下面是一个完整的、可运行的单隐藏层神经网络实现：

#include <iostream>#include <vector>#include <cmath>#include <random>// Sigmoid 激活函数double sigmoid(double x) {    return 1.0 / (1.0 + std::exp(-x));}// Sigmoid 的导数double sigmoid_derivative(double x) {    return x * (1 - x);}class NeuralNetwork {private:    std::vector<std::vector<double>> weights_input_hidden;    std::vector<std::vector<double>> weights_hidden_output;    std::vector<double> bias_hidden;    std::vector<double> bias_output;public:    // 构造函数：初始化网络    NeuralNetwork(int input_nodes, int hidden_nodes, int output_nodes) {        std::random_device rd;        std::mt19937 gen(rd());        std::uniform_real_distribution<> dis(-1.0, 1.0);        // 初始化输入到隐藏层的权重        weights_input_hidden.resize(input_nodes, std::vector<double>(hidden_nodes));        for (int i = 0; i < input_nodes; ++i) {            for (int j = 0; j < hidden_nodes; ++j) {                weights_input_hidden[i][j] = dis(gen);            }        }        // 初始化隐藏到输出层的权重        weights_hidden_output.resize(hidden_nodes, std::vector<double>(output_nodes));        for (int i = 0; i < hidden_nodes; ++i) {            for (int j = 0; j < output_nodes; ++j) {                weights_hidden_output[i][j] = dis(gen);            }        }        // 初始化偏置        bias_hidden.assign(hidden_nodes, 0.0);        bias_output.assign(output_nodes, 0.0);    }    // 前向传播    std::vector<double> forward(const std::vector<double>& input) {        // 隐藏层计算        std::vector<double> hidden = bias_hidden;        for (size_t i = 0; i < hidden.size(); ++i) {            for (size_t j = 0; j < input.size(); ++j) {                hidden[i] += input[j] * weights_input_hidden[j][i];            }            hidden[i] = sigmoid(hidden[i]);        }        // 输出层计算        std::vector<double> output = bias_output;        for (size_t i = 0; i < output.size(); ++i) {            for (size_t j = 0; j < hidden.size(); ++j) {                output[i] += hidden[j] * weights_hidden_output[j][i];            }            output[i] = sigmoid(output[i]);        }        return output;    }    // 简单的训练函数（仅用于演示）    void train(const std::vector<double>& input, const std::vector<double>& target, double learning_rate = 0.1) {        // 前向传播获取输出        std::vector<double> hidden = bias_hidden;        for (size_t i = 0; i < hidden.size(); ++i) {            for (size_t j = 0; j < input.size(); ++j) {                hidden[i] += input[j] * weights_input_hidden[j][i];            }            hidden[i] = sigmoid(hidden[i]);        }        std::vector<double> output = bias_output;        for (size_t i = 0; i < output.size(); ++i) {            for (size_t j = 0; j < hidden.size(); ++j) {                output[i] += hidden[j] * weights_hidden_output[j][i];            }            output[i] = sigmoid(output[i]);        }        // 反向传播（简化版）        std::vector<double> output_error(output.size());        for (size_t i = 0; i < output.size(); ++i) {            output_error[i] = target[i] - output[i];        }        // 更新输出层权重        for (size_t i = 0; i < hidden.size(); ++i) {            for (size_t j = 0; j < output.size(); ++j) {                double delta = output_error[j] * sigmoid_derivative(output[j]);                weights_hidden_output[i][j] += learning_rate * delta * hidden[i];                bias_output[j] += learning_rate * delta;            }        }        // 更新隐藏层权重        for (size_t i = 0; i < input.size(); ++i) {            for (size_t j = 0; j < hidden.size(); ++j) {                double hidden_error = 0.0;                for (size_t k = 0; k < output.size(); ++k) {                    hidden_error += output_error[k] * weights_hidden_output[j][k];                }                double delta = hidden_error * sigmoid_derivative(hidden[j]);                weights_input_hidden[i][j] += learning_rate * delta * input[i];                bias_hidden[j] += learning_rate * delta;            }        }    }};// 主函数：测试网络int main() {    // 创建一个 2-3-1 网络（2输入，3隐藏，1输出）    NeuralNetwork nn(2, 3, 1);    // 训练数据：模拟 XOR 问题（简化版）    std::vector<std::vector<double>> inputs = {{0,0}, {0,1}, {1,0}, {1,1}};    std::vector<std::vector<double>> targets = {{0}, {1}, {1}, {0}};    // 训练10000轮    for (int epoch = 0; epoch < 10000; ++epoch) {        for (size_t i = 0; i < inputs.size(); ++i) {            nn.train(inputs[i], targets[i]);        }    }    // 测试    std::cout << "测试结果:\n";    for (const auto& input : inputs) {        auto output = nn.forward(input);        std::cout << "输入: [" << input[0] << ", " << input[1]                   << "] -> 输出: " << output[0] << "\n";    }    return 0;}

第四步：编译与运行

将上述代码保存为 NeuralNetwork.cpp，然后在终端执行：

g++ -std=c++11 NeuralNetwork.cpp -o NeuralNetwork./NeuralNetwork

你将看到类似以下的输出（由于随机初始化，结果略有不同）：

测试结果:输入: [0, 0] -> 输出: 0.03输入: [0, 1] -> 输出: 0.97输入: [1, 0] -> 输出: 0.96输入: [1, 1] -> 输出: 0.04

总结与进阶

恭喜你！你已经成功用C++实现了一个基础的神经网络。这个神经网络入门教程涵盖了前向传播、反向传播和训练循环的核心逻辑。

下一步，你可以尝试：

• 增加更多隐藏层（实现深度网络）
• 使用更高效的矩阵运算库（如Eigen）
• 支持批量训练（Mini-batch）
• 添加保存/加载模型的功能

掌握从零实现神经网络的能力，不仅能加深你对AI原理的理解，还能为未来开发高性能AI应用打下坚实基础。继续加油吧！