基于numpy及pandas等bp神经网络多元回归单隐藏层relu激活函数 定义损失函数及优化器 初始化模型参数等代码

下面是使用 NumPy 和 Pandas 实现的 bp 神经网络多元回归单隐藏层 relu 激活函数模型的代码：

import numpy as np
import pandas as pd

# 定义模型
class Net(object):
    def __init__(self, input_size, hidden_size, output_size):
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.output_size = output_size

        # 初始化模型参数
        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 forward(self, X):
        # 前向传播
        self.z1 = np.dot(X, self.W1) + self.b1
        self.a1 = np.maximum(0, self.z1) # relu 激活函数
        self.z2 = np.dot(self.a1, self.W2) + self.b2
        return self.z2

    def backward(self, X, y, y_hat, learning_rate):
        # 反向传播
        m = X.shape[0]
        delta3 = y_hat - y
        dW2 = (1/m) * np.dot(self.a1.T, delta3)
        db2 = (1/m) * np.sum(delta3, axis=0, keepdims=True)
        delta2 = np.dot(delta3, self.W2.T) * (self.a1 > 0)
        dW1 = (1/m) * np.dot(X.T, delta2)
        db1 = (1/m) * np.sum(delta2, axis=0, keepdims=True)

        # 更新模型参数
        self.W2 -= learning_rate * dW2
        self.b2 -= learning_rate * db2
        self.W1 -= learning_rate * dW1
        self.b1 -= learning_rate * db1

# 定义损失函数
def loss(y_hat, y):
    return np.mean((y_hat - y)**2)

# 定义优化器
def optimize(X, y, model, num_iterations, learning_rate):
    for i in range(num_iterations):
        y_hat = model.forward(X)
        cost = loss(y_hat, y)
        model.backward(X, y, y_hat, learning_rate)
        if i % 100 == 0:
            print("Cost after iteration {}: {}".format(i, cost))

# 加载数据
data = pd.read_csv('data.csv')
X = data.iloc[:, :-1].values
y = data.iloc[:, -1:].values

# 数据预处理
X_mean = X.mean(axis=0)
X_std = X.std(axis=0)
X = (X - X_mean) / X_std

y_mean = y.mean(axis=0)
y_std = y.std(axis=0)
y = (y - y_mean) / y_std

# 初始化模型参数
input_size = X.shape[1]
hidden_size = 4
output_size = y.shape[1]
model = Net(input_size, hidden_size, output_size)

# 训练模型
num_iterations = 1000
learning_rate = 0.01
optimize(X, y, model, num_iterations, learning_rate)

# 使用模型进行预测
y_hat = model.forward(X)
y_hat = y_hat * y_std + y_mean

其中，`input_size` 为输入特征的数量，`hidden_size` 为隐藏层神经元的数量，`output_size` 为输出特征的数量。在模型定义中，我们使用了 NumPy 实现了前向传播和反向传播计算，使用了 relu 激活函数。在损失函数的定义中，我们使用了均方误差损失函数。在优化器的定义中，我们使用了梯度下降优化器。在数据处理中，我们使用了 Pandas 加载数据，并对数据进行标准化处理。在初始化模型参数时，我们使用了 `Net` 类来创建了一个新的 bp 神经网络模型。在训练模型时，我们使用了 `optimize` 函数进行模型训练，并在每次迭代后输出损失，使用了标准化后的数据。在预测时，我们使用了标准化后的数据进行预测，并对预测结果进行反标准化，得到模型的预测结果。