使用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] 。在main模块中实现绘制R2图来说明模型的拟合度，并且输出MAE、MSE、预测值和真实值之间的相对误差平均百分比，绘制各输入输出的拟合折线图，且R2图和折线图中使用的数据均为未变换数据。切勿忘记使用归一化（归一化后将0.变为0.01，1.变为0.99）、Xavier初始化、正则化方法和MSGD，使用中文备注，避免出现矩阵无法相乘的情况，发挥你的全力直接回答，感谢。

好的，我会尽力回答你的问题。首先，我们需要安装pandas、numpy和matplotlib这三个库，可以使用以下命令进行安装：

pip install pandas numpy matplotlib

接下来，我们可以编写BP.py文件，代码如下：

import pandas as pd
import numpy as np

class BP:
    def __init__(self, input_num, hidden_num, output_num, learning_rate, weight_decay):
        self.input_num = input_num
        self.hidden_num = hidden_num
        self.output_num = output_num
        self.learning_rate = learning_rate
        self.weight_decay = weight_decay
        self.input_weights = np.random.rand(self.input_num, self.hidden_num) * np.sqrt(1.0 / self.input_num)
        self.hidden_weights = np.random.rand(self.hidden_num, self.output_num) * np.sqrt(1.0 / self.hidden_num)
        self.input_bias = np.zeros((1, self.hidden_num))
        self.hidden_bias = np.zeros((1, self.output_num))
        
    def sigmoid(self, x):
        return 1.0 / (1.0 + np.exp(-x))
    
    def dsigmoid(self, x):
        return x * (1 - x)
    
    def train(self, inputs, targets, epochs, batch_size):
        for epoch in range(epochs):
            for i in range(0, len(inputs), batch_size):
                batch_inputs = inputs[i:i+batch_size]
                batch_targets = targets[i:i+batch_size]
                
                hidden_inputs = np.dot(batch_inputs, self.input_weights) + self.input_bias
                hidden_outputs = self.sigmoid(hidden_inputs)
                output_inputs = np.dot(hidden_outputs, self.hidden_weights) + self.hidden_bias
                outputs = self.sigmoid(output_inputs)
                
                output_errors = batch_targets - outputs
                hidden_errors = np.dot(output_errors, self.hidden_weights.T) * self.dsigmoid(hidden_outputs)
                
                self.hidden_weights += self.learning_rate * np.dot(hidden_outputs.T, output_errors) - self.weight_decay * self.hidden_weights
                self.input_weights += self.learning_rate * np.dot(batch_inputs.T, hidden_errors) - self.weight_decay * self.input_weights
                self.hidden_bias += self.learning_rate * np.sum(output_errors, axis=0, keepdims=True)
                self.input_bias += self.learning_rate * np.sum(hidden_errors, axis=0, keepdims=True)
                
    def predict(self, inputs):
        hidden_inputs = np.dot(inputs, self.input_weights) + self.input_bias
        hidden_outputs = self.sigmoid(hidden_inputs)
        output_inputs = np.dot(hidden_outputs, self.hidden_weights) + self.hidden_bias
        outputs = self.sigmoid(output_inputs)
        return outputs

在这个类中，我们定义了一个BP类，包含了初始化、sigmoid函数、训练和预测等方法。其中，初始化方法定义了网络的输入节点数、隐藏节点数、输出节点数、学习率和权重衰减系数，并使用Xavier初始化方法初始化了网络的权重和偏置。sigmoid函数和dsigmoid函数分别代表了sigmoid函数和其导数。

训练方法中使用了MSGD，对数据集进行了批量处理，计算了前向传播和反向传播中的误差，并更新了权重和偏置。预测方法中，输入数据经过前向传播计算，得到输出。

接下来，我们可以编写main.py文件，代码如下：

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from BP import BP

# 读取数据
data = pd.read_excel("NEW.xlsx", header=None)
train_data = data.iloc[1:3001, [9, 10, 11, 12, 13, 14, 16, 17]].values
test_data = data.iloc[3001:, [9, 10, 11, 12, 13, 14, 16, 17]].values
train_target = data.iloc[1:3001, -2].values.reshape((-1, 1))
test_target = data.iloc[3001:, -2].values.reshape((-1, 1))

# 数据归一化
train_data = (train_data - np.min(train_data)) / (np.max(train_data) - np.min(train_data)) * 0.98 + 0.01
test_data = (test_data - np.min(test_data)) / (np.max(test_data) - np.min(test_data)) * 0.98 + 0.01
train_target = (train_target - np.min(train_target)) / (np.max(train_target) - np.min(train_target)) * 0.98 + 0.01
test_target = (test_target - np.min(test_target)) / (np.max(test_target) - np.min(test_target)) * 0.98 + 0.01

# 创建BP网络
bp = BP(input_num=8, hidden_num=5, output_num=1, learning_rate=0.1, weight_decay=0.01)

# 训练网络
bp.train(train_data, train_target, epochs=1000, batch_size=32)

# 预测结果
pred_train = bp.predict(train_data)
pred_test = bp.predict(test_data)

# 绘制R2图
train_r2 = 1 - np.sum((train_target - pred_train) ** 2) / np.sum((train_target - np.mean(train_target)) ** 2)
test_r2 = 1 - np.sum((test_target - pred_test) ** 2) / np.sum((test_target - np.mean(test_target)) ** 2)
plt.bar(["train", "test"], [train_r2, test_r2])
plt.xlabel("dataset")
plt.ylabel("R2")
plt.title("R2")
plt.show()

# 输出MAE、MSE、预测值和真实值之间的相对误差平均百分比
train_mae = np.mean(np.abs(train_target - pred_train))
test_mae = np.mean(np.abs(test_target - pred_test))
train_mse = np.mean((train_target - pred_train) ** 2)
test_mse = np.mean((test_target - pred_test) ** 2)
train_error_percent = np.mean(np.abs(train_target - pred_train) / train_target) * 100
test_error_percent = np.mean(np.abs(test_target - pred_test) / test_target) * 100
print("train mae:", train_mae)
print("test mae:", test_mae)
print("train mse:", train_mse)
print("test mse:", test_mse)
print("train error percent:", train_error_percent, "%")
print("test error percent:", test_error_percent, "%")

# 绘制各输入输出的拟合折线图
plt.figure(figsize=(10, 8))
for i in range(8):
    plt.subplot(4, 2, i+1)
    plt.plot(train_data[:, i], train_target, "bo", label="train")
    plt.plot(train_data[:, i], pred_train, "r", label="predict")
    plt.xlabel("input"+str(i+1))
    plt.ylabel("output")
    plt.title("input"+str(i+1))
plt.tight_layout()
plt.show()

在这个模块中，我们首先读取数据，使用归一化方法将数据进行处理。接着，我们创建了一个BP网络，并对训练集进行训练，得到了预测结果。然后，我们绘制了R2图，输出了MAE、MSE、预测值和真实值之间的相对误差平均百分比，最后绘制了各输入输出的拟合折线图。

请注意，如果你使用了python 3.x版本，需要将print语句改为print()函数的形式。

以上就是使用python实现使用Xavier初始化、正则化方法和MSGD的BP网络的所有步骤，希望能够帮助到你。