使用python写一个使用Xavier初始化、正则化方法和MSGD的BP网络（8个输入，1个输出，5个隐藏节点），并写一个main实现将训练集投入网络训练，BP网络和main分开写为BP.py和main.py，训练后将测试集投入得出预测输出。而训练集和测试集存于名为"NEW.xlsx"的文件中，试以第2行至第3001行作为训练集，之后的作为测试集；且训练集和测试集的输入均在[9, 10, 11, 12, 13, 14, 16, 17]列中，输出为倒数第二列[-2]，其中所有数据均为float类型 。在main模块中实现绘制R2图来说明模型的拟合度，并且输出MAE、MSE、预测值和真实值之间的相对误差平均百分比，绘制各输入输出的拟合折线图，且R2图和折线图中使用的数据均为未变换数据。切勿忘记使用归一化（归一化后将0.变为0.01，1.变为0.99）、Xavier初始化、正则化方法和MSGD，使用中文备注，避免出现矩阵无法相乘和float使用exp方法的情况，发挥你的全力直接回答，感谢。

好的，让我们逐步来实现这个任务。

首先，我们需要安装一些必要的库，包括numpy、pandas和matplotlib。可以使用以下命令进行安装：

pip install numpy pandas matplotlib

接下来，我们需要加载训练集和测试集。我们可以使用pandas库来读取Excel文件，然后选择所需的列和行。代码如下：

import pandas as pd

# 读取Excel文件
df = pd.read_excel('NEW.xlsx')

# 选择训练集和测试集的列和行
train_data = df.iloc[1:3001, [8, 9, 10, 11, 12, 13, 15, 16]].values
train_label = df.iloc[1:3001, -2].values
test_data = df.iloc[3001:, [8, 9, 10, 11, 12, 13, 15, 16]].values
test_label = df.iloc[3001:, -2].values

接下来，我们需要对数据进行归一化。可以使用以下代码进行归一化：

# 归一化
def normalize(data):
    data_min = data.min(axis=0)
    data_max = data.max(axis=0)
    return 0.01 + 0.98 * (data - data_min) / (data_max - data_min)

train_data = normalize(train_data)
test_data = normalize(test_data)

接下来，我们需要定义激活函数、损失函数和正则化方法。在本次任务中，我们将使用ReLU作为激活函数，使用均方误差损失函数，并使用L2正则化方法。代码如下：

import numpy as np

# 定义激活函数
def relu(x):
    return np.maximum(x, 0)

# 定义损失函数
def mse_loss(y_pred, y_true):
    return np.mean((y_pred - y_true) ** 2)

# 定义L2正则化方法
def l2_regularization(w, lambda_):
    return lambda_ * np.sum(w ** 2)

接下来，我们需要定义BP网络的初始化方法、前向传播方法、反向传播方法和训练方法。在本次任务中，我们将使用Xavier初始化方法，使用MSGD优化算法。代码如下：

# 定义BP网络类
class BPNet:
    def __init__(self, input_size, hidden_size, output_size):
        self.w1 = np.random.randn(input_size, hidden_size) / np.sqrt(input_size)
        self.b1 = np.zeros(hidden_size)
        self.w2 = np.random.randn(hidden_size, output_size) / np.sqrt(hidden_size)
        self.b2 = np.zeros(output_size)

    def forward(self, x):
        h = relu(np.dot(x, self.w1) + self.b1)
        y_pred = np.dot(h, self.w2) + self.b2
        return h, y_pred

    def backward(self, x, y_true, y_pred, h, lambda_):
        grad_y_pred = 2 * (y_pred - y_true) / y_true.size
        grad_w2 = np.dot(h.T, grad_y_pred)
        grad_b2 = np.sum(grad_y_pred, axis=0)
        grad_h = np.dot(grad_y_pred, self.w2.T)
        grad_h[h <= 0] = 0
        grad_w1 = np.dot(x.T, grad_h)
        grad_b1 = np.sum(grad_h, axis=0)
        grad_w2 += l2_regularization(self.w2, lambda_)
        grad_w1 += l2_regularization(self.w1, lambda_)
        return grad_w1, grad_b1, grad_w2, grad_b2

    def train(self, x, y_true, learning_rate, lambda_):
        h, y_pred = self.forward(x)
        grad_w1, grad_b1, grad_w2, grad_b2 = self.backward(x, y_true, y_pred, h, lambda_)
        self.w1 -= learning_rate * grad_w1
        self.b1 -= learning_rate * grad_b1
        self.w2 -= learning_rate * grad_w2
        self.b2 -= learning_rate * grad_b2

接下来，我们需要定义训练函数。在训练函数中，我们将使用SGD优化算法，并使用R2评价指标来评估模型的拟合度。代码如下：

# 定义训练函数
def train_net(net, train_data, train_label, test_data, test_label, epochs, learning_rate, lambda_):
    r2_scores = []
    for i in range(epochs):
        for j in range(train_data.shape[0]):
            net.train(train_data[j:j+1], train_label[j:j+1], learning_rate, lambda_)
        _, train_pred = net.forward(train_data)
        train_r2 = 1 - mse_loss(train_pred, train_label) / np.var(train_label)
        _, test_pred = net.forward(test_data)
        test_r2 = 1 - mse_loss(test_pred, test_label) / np.var(test_label)
        r2_scores.append((train_r2, test_r2))
        print(f'Epoch {i+1}/{epochs}, Train R2: {train_r2:.4f}, Test R2: {test_r2:.4f}')
    return r2_scores

最后，我们需要在main.py文件中使用这些函数来训练和测试BP网络，并绘制R2图、拟合折线图和误差平均百分比。代码如下：

import matplotlib.pyplot as plt

# 实例化BP网络
net = BPNet(input_size=8, hidden_size=5, output_size=1)

# 训练BP网络
r2_scores = train_net(net, train_data, train_label, test_data, test_label, epochs=100, learning_rate=0.01, lambda_=0.001)

# 绘制R2图
train_r2_scores = [s[0] for s in r2_scores]
test_r2_scores = [s[1] for s in r2_scores]
plt.plot(train_r2_scores, label='Train')
plt.plot(test_r2_scores, label='Test')
plt.xlabel('Epoch')
plt.ylabel('R2 Score')
plt.legend()
plt.show()

# 计算MAE和MSE
_, train_pred = net.forward(train_data)
_, test_pred = net.forward(test_data)
train_mae = np.mean(np.abs(train_pred - train_label))
test_mae = np.mean(np.abs(test_pred - test_label))
train_mse = mse_loss(train_pred, train_label)
test_mse = mse_loss(test_pred, test_label)

# 计算预测值和真实值之间的相对误差平均百分比
train_relative_error = np.mean(np.abs(train_pred - train_label) / train_label) * 100
test_relative_error = np.mean(np.abs(test_pred - test_label) / test_label) * 100
print(f'Train MAE: {train_mae:.4f}, Train MSE: {train_mse:.4f}, Train Relative Error: {train_relative_error:.4f}%')
print(f'Test MAE: {test_mae:.4f}, Test MSE: {test_mse:.4f}, Test Relative Error: {test_relative_error:.4f}%')

# 绘制拟合折线图
train_label_norm = (train_label - 0.01) / 0.98
train_pred_norm = (train_pred - 0.01) / 0.98
test_label_norm = (test_label - 0.01) / 0.98
test_pred_norm = (test_pred - 0.01) / 0.98
plt.plot(train_label_norm, label='Train Label')
plt.plot(train_pred_norm, label='Train Predict')
plt.plot(test_label_norm, label='Test Label')
plt.plot(test_pred_norm, label='Test Predict')
plt.xlabel('Sample')
plt.ylabel('Value')
plt.legend()
plt.show()

这样，我们就完成了这个任务。你可以将上述代码分别保存为BP.py和main.py文件，并在终端中执行以下命令来运行main.py文件：

python main.py