bp神经网络多元回归预测单层隐藏层relu函数代码实例分析

好的，以下是一个使用反向传播算法的单隐藏层神经网络的多元回归预测代码实例分析，其中激活函数采用ReLU函数：

import numpy as np

class NeuralNetwork:
    def __init__(self, num_inputs, num_hidden, num_outputs):
        self.input_size = num_inputs
        self.hidden_size = num_hidden
        self.output_size = num_outputs
        
        self.W1 = np.random.randn(self.input_size, self.hidden_size) * 0.01
        self.b1 = np.zeros((1, self.hidden_size))
        self.W2 = np.random.randn(self.hidden_size, self.output_size) * 0.01
        self.b2 = np.zeros((1, self.output_size))
        
    def relu(self, Z):
        return np.maximum(0, Z)
    
    def forward(self, X):
        Z1 = np.dot(X, self.W1) + self.b1
        A1 = self.relu(Z1)
        Z2 = np.dot(A1, self.W2) + self.b2
        y_hat = Z2
        return y_hat
    
    def relu_derivative(self, Z):
        return np.where(Z > 0, 1, 0)
    
    def backward(self, X, y, learning_rate):
        y_hat = self.forward(X)
        
        dZ2 = y_hat - y
        dW2 = np.dot(self.relu(self.W1), dZ2)
        db2 = np.sum(dZ2, axis=0, keepdims=True)
        
        dZ1 = np.dot(dZ2, self.W2.T) * self.relu_derivative(self.W1)
        dW1 = np.dot(X.T, dZ1)
        db1 = np.sum(dZ1, axis=0)
        
        self.W2 -= learning_rate * dW2
        self.b2 -= learning_rate * db2
        self.W1 -= learning_rate * dW1
        self.b1 -= learning_rate * db1
        
    def train(self, X, y, num_epochs, learning_rate):
        for i in range(num_epochs):
            self.backward(X, y, learning_rate)
            if i % 100 == 0:
                loss = np.mean(np.square(y - self.forward(X)))
                print(f"Epoch {i} - Loss: {loss:.4f}")

首先，在初始化函数中，我们指定了输入层、隐藏层和输出层的神经元数量，并随机初始化了两个权值矩阵`W1`和`W2`，以及两个偏置向量`b1`和`b2`。其中，`W1`的维度为`(num_inputs, num_hidden)`，`W2`的维度为`(num_hidden, num_outputs)`。

在`forward`函数中，我们首先计算隐藏层的输入`Z1`，即输入`X`与`W1`的乘积加上`b1`，然后通过ReLU函数计算出隐藏层的输出`A1`，即`relu(Z1)`。接着，我们计算输出层的输入`Z2`，即隐藏层的输出`A1`与`W2`的乘积加上`b2`，最后计算输出层的输出`y_hat`，即`Z2`。

在`relu`函数中，我们使用了ReLU函数，即`np.maximum(0, Z)`。ReLU函数在`Z > 0`时输出`Z`，在`Z <= 0`时输出0。

在`relu_derivative`函数中，我们计算了ReLU函数的导数，即`np.where(Z > 0, 1, 0)`。当`Z > 0`时，ReLU函数的导数为1，否则为0。

在`backward`函数中，我们首先计算输出层的误差`dZ2`，即预测值`y_hat`与真实值`y`之差。然后，我们计算输出层权值矩阵`W2`的梯度`dW2`，即隐藏层输出`A1`与误差`dZ2`的乘积。同时，我们也需要计算`b2`的梯度`db2`，即误差`dZ2`的和。接着，我们计算隐藏层的误差`dZ1`，即输出层误差`dZ2`与权值矩阵`W2`的转置的乘积乘以隐藏层输入`Z1`的导数。最后，我们计算隐藏层权值矩阵`W1`的梯度`dW1`，即输入`X`与误差`dZ1`的乘积，以及`b1`的梯度`db1`，即误差`dZ1`的和。最后，我们使用学习率`learning_rate`来更新权值和偏置。

在`train`函数中，我们使用反向传播算法来训练网络。对于每一个epoch，我们调用`backward`函数来计算梯度并更新权值和偏置。在每隔100个epoch时，我们打印当前的损失，即预测值与真实值之间的平方误差的均值。

需要注意的是，这段代码只是一个示例，实际使用中，我们需要根据具体的数据和任务进行相应的调整。