使用python创建一个使用归一化、Xavier初始化、正则化方法和MSGD的BP网络，该网络有8个输入1个输出1层隐藏层，要求分为两个模块（py文件），在确认输入、输出的训练集之后，模型不会出现shape类报错，且一个是BP网络，另一个是主函数，在每句代码后添加注释；训练集数据存于xlsx表格前3000行中，测试集为之后的40行，且均为float类型。并且能够输出各输入的权重。尝试在main模块中实现将训练后的BP网络模型输出为一个文件，绘制R2图来说明模型的拟合度，并且输出MAE、MSE、预测值和真实值之间的相对误差平均百分比，绘制测试集的各输入对应的实际输出和预测输出的拟合折线图，且R2图和折线图中使用的数据均为未变换数据。

很高兴回答您的问题。这是一个比较复杂的问题，需要涉及到许多知识点，我会尽可能详细地给出代码和注释。首先，我们需要安装一些必要的库，包括pandas，numpy和openpyxl，可以使用以下命令进行安装：

!pip install pandas numpy openpyxl

接下来，我们分为两个模块进行编写，第一个是BP网络模块，我们将其命名为bp_network.py。代码如下：

import numpy as np
import pandas as pd

class BPNetwork:
    def __init__(self, input_size, hidden_size, output_size, learning_rate, reg_lambda, momentum):
        """
        初始化网络参数，并进行归一化和Xavier初始化
        :param input_size: 输入层大小
        :param hidden_size: 隐藏层大小
        :param output_size: 输出层大小
        :param learning_rate: 学习率
        :param reg_lambda: 正则化项系数
        :param momentum: 动量因子
        """
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.output_size = output_size
        self.learning_rate = learning_rate
        self.reg_lambda = reg_lambda
        self.momentum = momentum
        
        # 初始化权重和偏置
        self.W1 = np.random.randn(self.input_size, self.hidden_size) * np.sqrt(2.0 / (self.input_size + self.hidden_size)) # Xavier初始化
        self.b1 = np.zeros((1, self.hidden_size))
        self.W2 = np.random.randn(self.hidden_size, self.output_size) * np.sqrt(2.0 / (self.hidden_size + self.output_size)) # Xavier初始化
        self.b2 = np.zeros((1, self.output_size))
        
        # 初始化动量参数
        self.v_W1 = np.zeros((self.input_size, self.hidden_size))
        self.v_b1 = np.zeros((1, self.hidden_size))
        self.v_W2 = np.zeros((self.hidden_size, self.output_size))
        self.v_b2 = np.zeros((1, self.output_size))
        
    def sigmoid(self, x):
        """
        sigmoid激活函数
        """
        return 1 / (1 + np.exp(-x))
    
    def sigmoid_derivative(self, x):
        """
        sigmoid激活函数的导数
        """
        return x * (1 - x)
    
    def forward(self, X):
        """
        前向传播
        """
        self.z1 = np.dot(X, self.W1) + self.b1
        self.a1 = self.sigmoid(self.z1)
        self.z2 = np.dot(self.a1, self.W2) + self.b2
        self.y_hat = self.z2
        
        return self.y_hat
    
    def backward(self, X, y, y_hat):
        """
        反向传播
        """
        # 计算输出层误差
        delta2 = y_hat - y
        # 计算隐藏层误差
        delta1 = np.dot(delta2, self.W2.T) * self.sigmoid_derivative(self.a1)
        
        # 计算输出层权重和偏置的梯度
        dW2 = np.dot(self.a1.T, delta2) + self.reg_lambda * self.W2
        db2 = np.sum(delta2, axis=0, keepdims=True)
        # 计算隐藏层权重和偏置的梯度
        dW1 = np.dot(X.T, delta1) + self.reg_lambda * self.W1
        db1 = np.sum(delta1, axis=0)
        
        # 更新权重和偏置
        self.v_W2 = self.momentum * self.v_W2 - self.learning_rate * dW2
        self.v_b2 = self.momentum * self.v_b2 - self.learning_rate * db2
        self.W2 += self.v_W2
        self.b2 += self.v_b2
        self.v_W1 = self.momentum * self.v_W1 - self.learning_rate * dW1
        self.v_b1 = self.momentum * self.v_b1 - self.learning_rate * db1
        self.W1 += self.v_W1
        self.b1 += self.v_b1
        
    def train(self, X_train, y_train, X_test, y_test, epochs):
        """
        训练网络
        """
        train_loss = []
        test_loss = []
        for i in range(epochs):
            # 前向传播
            y_hat_train = self.forward(X_train)
            y_hat_test = self.forward(X_test)
            
            # 计算训练集和测试集的损失
            train_loss.append(np.mean(np.square(y_train - y_hat_train)))
            test_loss.append(np.mean(np.square(y_test - y_hat_test)))
            
            # 反向传播
            self.backward(X_train, y_train, y_hat_train)
            
            # 输出每100个epoch的损失
            if i % 100 == 0:
                print("Epoch: {}, train_loss: {:.4f}, test_loss: {:.4f}".format(i, train_loss[i], test_loss[i]))
        
        # 输出每个输入的权重
        print("Weights of input features:")
        for i in range(self.input_size):
            print("Feature {}: {}".format(i+1, self.W1[i]))
            
        # 返回训练集和测试集的损失
        return train_loss, test_loss
    
    def predict(self, X):
        """
        预测
        """
        return self.forward(X)

上面的代码定义了一个BP网络类，包括初始化参数、sigmoid激活函数、前向传播、反向传播、训练和预测方法。其中，前向传播和反向传播分别计算输出和隐藏层的输出，以及权重和偏置的梯度，并进行更新。训练方法使用了动量的梯度下降法进行优化。在训练完成后，我们可以输出每个输入的权重，用于分析各个输入对输出的影响。

接下来，我们编写主函数模块，命名为main.py。代码如下：

import numpy as np
import pandas as pd
from bp_network import BPNetwork

# 读取训练集和测试集数据
train_data = pd.read_excel('data.xlsx', nrows=3000)
test_data = pd.read_excel('data.xlsx', skiprows=range(1, 3000), nrows=40)

# 将数据转换为numpy数组，并进行归一化
X_train = train_data.iloc[:, :-1].values
y_train = train_data.iloc[:, -1:].values
X_mean = np.mean(X_train, axis=0)
X_std = np.std(X_train, axis=0)
X_train = (X_train - X_mean) / X_std
y_mean = np.mean(y_train, axis=0)
y_std = np.std(y_train, axis=0)
y_train = (y_train - y_mean) / y_std
X_test = test_data.iloc[:, :-1].values
y_test = test_data.iloc[:, -1:].values
X_test = (X_test - X_mean) / X_std
y_test = (y_test - y_mean) / y_std

# 创建BP网络模型
model = BPNetwork(input_size=8, hidden_size=16, output_size=1, learning_rate=0.01, reg_lambda=0.01, momentum=0.9)

# 训练模型
train_loss, test_loss = model.train(X_train, y_train, X_test, y_test, epochs=1000)

# 预测测试集并进行反归一化
y_pred = model.predict(X_test)
y_pred = y_pred * y_std + y_mean
y_test = y_test * y_std + y_mean

# 计算MAE和MSE
mae = np.mean(np.abs(y_pred - y_test))
mse = np.mean(np.square(y_pred - y_test))
print("MAE: {:.4f}, MSE: {:.4f}".format(mae, mse))

# 计算预测值和真实值之间的相对误差平均百分比
error = np.abs((y_pred - y_test) / y_test)
mean_error = np.mean(error) * 100
print("Mean relative error: {:.2f}%".format(mean_error))

# 绘制R2图
import matplotlib.pyplot as plt
from sklearn.metrics import r2_score
r2 = r2_score(y_test, y_pred)
plt.scatter(y_test, y_pred)
plt.plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'k--', lw=4)
plt.xlabel('Actual')
plt.ylabel('Predicted')
plt.title('R2: {:.4f}'.format(r2))
plt.show()

# 绘制测试集的各输入对应的实际输出和预测输出的拟合折线图
fig, ax = plt.subplots(figsize=(10, 6))
for i in range(X_test.shape[1]):
    ax.plot(X_test[:, i], y_test, 'o', label='Actual')
    ax.plot(X_test[:, i], y_pred, 'x', label='Predicted')
    ax.set_xlabel('Feature {}'.format(i+1))
    ax.set_ylabel('Output')
    ax.set_title('Input Feature {} vs Output'.format(i+1))
    ax.legend()
    plt.show()

# 将训练后的模型保存为文件
import pickle
with open('model.pkl', 'wb') as f:
    pickle.dump(model, f)

上面的代码首先读取了训练集和测试集数据，并进行了归一化处理。接着，我们使用BPNetwork类创建了一个BP网络模型，并进行了训练。训练完成后，我们使用模型对测试集进行了预测，并进行了反归一化处理。然后，我们计算了MAE和MSE，并输出了预测值和真实值之间的相对误差平均百分比。接着，我们绘制了R2图和测试集的各输入对应的实际输出和预测输出的拟合折线图。最后，我们将训练后的模型保存为文件，以便以后使用。

综上所述，我们完成了一个使用归一化、Xavier初始化、正则化方法和MSGD的BP网络，并使用训练集和测试集进行了训练和测试，并且能够输出各输入的权重。我们还实现了将训练后的模型保存为文件，绘制R2图，计算MAE和MSE，并输出预测值和真实值之间的相对误差平均百分比，以及绘制测试集的各输入对应的实际输出和预测输出的拟合折线图。