深入探讨神经网络：从BP、RBF到NN-PID的C++实现

深入探讨神经网络：从BP、RBF到NN-PID的C++实现

一、引言

神经网络作为一种强大的机器学习方法，已经在模式识别、分类、预测等领域得到了广泛应用。本文将详细介绍几种常见的神经网络，包括BP神经网络、RBF神经网络以及神经网络PID（NN-PID）控制器，并通过C++代码示例展示其实现过程。希望通过本文的讲解，读者能够深入理解神经网络的原理和应用。

二、BP神经网络

2.1 BP神经网络原理

BP（Back Propagation，反向传播）神经网络是最常见的前馈神经网络之一。它通过误差反向传播算法来调整网络的权重和偏置，从而最小化预测误差。BP神经网络的基本结构包括输入层、隐藏层和输出层，每层节点通过权重连接。

2.2 BP神经网络的C++实现

以下是BP神经网络的C++实现，包括网络初始化、前向传播、反向传播和训练等功能：

#include <iostream>
#include <vector>
#include <cmath>
#include <cstdlib>
#include <ctime>

class BPNetwork {
   
public:
    BPNetwork(int inputSize, int hiddenSize, int outputSize) 
        : inputSize(inputSize), hiddenSize(hiddenSize), outputSize(outputSize) {
   
        initializeWeights();
    }

    std::vector<double> forward(const std::vector<double>& input) {
   
        // 输入层到隐藏层
        hiddenLayer.resize(hiddenSize);
        for (int i = 0; i < hiddenSize; ++i) {
   
            hiddenLayer[i] = 0.0;
            for (int j = 0; j < inputSize; ++j) {
   
                hiddenLayer[i] += input[j] * inputToHiddenWeights[i][j];
            }
            hiddenLayer[i] += hiddenBias[i];
            hiddenLayer[i] = sigmoid(hiddenLayer[i]);
        }

        // 隐藏层到输出层
        outputLayer.resize(outputSize);
        for (int i = 0; i < outputSize; ++i) {
   
            outputLayer[i] = 0.0;
            for (int j = 0; j < hiddenSize; ++j) {
   
                outputLayer[i] += hiddenLayer[j] * hiddenToOutputWeights[i][j];
            }
            outputLayer[i] += outputBias[i];
            outputLayer[i] = sigmoid(outputLayer[i]);
        }

        return outputLayer;
    }

    void backward(const std::vector<double>& input, const std::vector<double>& target, double learningRate) {
   
        // 计算输出层误差
        std::vector<double> outputError(outputSize);
        for (int i = 0; i < outputSize; ++i) {
   
            outputError[i] = (outputLayer[i] - target[i]) * sigmoidDerivative(outputLayer[i]);
        }

        // 计算隐藏层误差
        std::vector<double> hiddenError(hiddenSize);
        for (int i = 0; i < hiddenSize; ++i) {
   
            hiddenError[i] = 0.0;
            for (int j = 0; j < outputSize; ++j) {
   
                hiddenError[i] += outputError[j] * hiddenToOutputWeights[j][i];
            }
            hiddenError[i] *= sigmoidDerivative(hiddenLayer[i]);
        }

        // 更新隐藏层到输出层的权重和偏置
        for (int i = 0; i < outputSize; ++i) {
   
            for (int j = 0; j < hiddenSize; ++j) {
   
                hiddenToOutputWeights[i][j] -= learningRate * outputError[i] * hiddenLayer[j];
            }
            outputBias[i] -= learningRate * outputError[i];
        }

        // 更新输入层到隐藏层的权重和偏置
        for (int i = 0; i < hiddenSize; ++i) {
   
            for (int j = 0; j < inputSize; ++j) {
   
                inputToHiddenWeights[i][j] -= learningRate * hiddenError[i] * input[j];
            }
            hiddenBias[i] -= learningRate * hiddenError[i];
        }
    }

    void train(const std::vector<std::vector<double>>& inputs, const std::vector<std::vector<double>>& targets, double learningRate, int epochs) {
   
        for (int epoch = 0; epoch < epochs; ++epoch) {
   
            double totalError = 0.0;
            for (size_t i = 0; i < inputs.si