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

很好，让我们按照您的要求逐步实现所需的功能。

首先，我们需要创建BP网络模块。在BP网络中，我们使用Sigmoid函数作为激活函数，同时使用归一化、Xavier初始化、正则化方法和MSGD来提高模型的稳定性和准确性。以下是BP网络模块代码实现：（命名为BPNet.py）

import numpy as np
import pandas as pd

class BPNet:
    def __init__(self, input_size, hidden_size, output_size, learning_rate, weight_decay, momentum):
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.output_size = output_size
        self.learning_rate = learning_rate
        self.weight_decay = weight_decay
        self.momentum = momentum
        
        # 初始化权重
        self.weights_ih = np.random.randn(self.hidden_size, self.input_size) / np.sqrt(self.input_size)
        self.weights_ho = np.random.randn(self.output_size, self.hidden_size) / np.sqrt(self.hidden_size)
        
        # 初始化偏置
        self.bias_h = np.zeros((self.hidden_size, 1))
        self.bias_o = np.zeros((self.output_size, 1))
        
        # 初始化动量
        self.velocity_ih = np.zeros((self.hidden_size, self.input_size))
        self.velocity_ho = np.zeros((self.output_size, self.hidden_size))
        
    def sigmoid(self, x):
        return 1 / (1 + np.exp(-x))
    
    def sigmoid_derivative(self, x):
        return x * (1 - x)
    
    def normalize(self, X):
        return (X - np.mean(X)) / np.std(X)
    
    def forward(self, X):
        X = self.normalize(X)  # 归一化
        X = np.array(X).reshape(-1, 1)
        
        # 输入层到隐藏层
        hidden = np.dot(self.weights_ih, X) + self.bias_h
        hidden = self.sigmoid(hidden)
        
        # 隐藏层到输出层
        output = np.dot(self.weights_ho, hidden) + self.bias_o
        output = self.sigmoid(output)
        
        return output
    
    def backward(self, X, y, output):
        # 计算误差
        y = np.array(y).reshape(-1, 1)
        error = y - output
        
        # 输出层到隐藏层
        output_derivative = self.sigmoid_derivative(output)
        delta_ho = error * output_derivative
        gradient_ho = np.dot(delta_ho, self.weights_ho)
        gradient_ho = gradient_ho.reshape(self.hidden_size, 1)
        
        # 输入层到隐藏层
        hidden_derivative = self.sigmoid_derivative(hidden)
        delta_ih = gradient_ho * hidden_derivative
        gradient_ih = np.dot(delta_ih, self.weights_ih)
        gradient_ih = gradient_ih.reshape(self.input_size, 1)
        
        # 更新权重和偏置
        hidden = np.array(hidden).reshape(self.hidden_size, 1)
        X = np.array(X).reshape(self.input_size, 1)
        self.velocity_ih = self.momentum * self.velocity_ih + (1 - self.momentum) * self.learning_rate * gradient_ih * X.T
        self.velocity_ho = self.momentum * self.velocity_ho + (1 - self.momentum) * self.learning_rate * delta_ho * hidden.T
        self.weights_ih += self.velocity_ih - self.learning_rate * self.weight_decay * self.weights_ih
        self.weights_ho += self.velocity_ho - self.learning_rate * self.weight_decay * self.weights_ho
        self.bias_h += self.learning_rate * delta_ih
        self.bias_o += self.learning_rate * delta_ho
    
    def train(self, X_train, y_train, epochs):
        for epoch in range(epochs):
            for i in range(len(X_train)):
                X = X_train[i]
                y = y_train[i]
                
                output = self.forward(X)
                self.backward(X, y, output)
                
    def predict(self, X_test):
        outputs = []
        for X in X_test:
            output = self.forward(X)
            outputs.append(output[0])
        return outputs

接下来，我们需要创建主函数模块，实现绘制R2图、输出MAE、MSE、预测值和真实值之间的相对误差平均百分比、绘制各输入输出的拟合折线图等功能。以下是主函数模块代码实现：（命名为main.py）

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

# 读取数据
data = pd.read_excel('data.xlsx')
X_train = data.iloc[:3000, :-1].values
y_train = data.iloc[:3000, -1].values
X_test = data.iloc[3000:, :-1].values
y_test = data.iloc[3000:, -1].values

# 创建BP网络模型
input_size = 8
hidden_size = 10
output_size = 1
learning_rate = 0.1
weight_decay = 0.001
momentum = 0.9
bpnet = BPNet(input_size, hidden_size, output_size, learning_rate, weight_decay, momentum)

# 训练模型
epochs = 100
bpnet.train(X_train, y_train, epochs)

# 预测结果
y_pred = bpnet.predict(X_test)

# 绘制R2图
plt.scatter(y_test, y_pred)
plt.xlabel('True Values')
plt.ylabel('Predictions')
plt.xlim([0, plt.xlim()[1]])
plt.ylim([0, plt.ylim()[1]])
plt.plot([0, 1], [0, 1], 'r--')
plt.title('R2 Score: {:.3f}'.format(np.corrcoef(y_test, y_pred)[0][1]**2))
plt.show()

# 输出MAE、MSE、预测值和真实值之间的相对误差平均百分比
mae = np.mean(np.abs(y_pred - y_test))
mse = np.mean((y_pred - y_test)**2)
mape = np.mean(np.abs((y_test - y_pred) / y_test)) * 100
print('MAE: {:.3f}'.format(mae))
print('MSE: {:.3f}'.format(mse))
print('MAPE: {:.3f}%'.format(mape))

# 绘制各输入输出的拟合折线图
fig, axs = plt.subplots(nrows=2, ncols=4, figsize=(15, 6))
for i in range(input_size):
    row = i // 4
    col = i % 4
    axs[row, col].scatter(X_test[:, i], y_test, s=1)
    axs[row, col].scatter(X_test[:, i], y_pred, s=1)
    axs[row, col].set_xlabel('Input {}'.format(i+1))
    axs[row, col].set_ylabel('Output')
plt.tight_layout()
plt.show()

以上代码实现了使用归一化、Xavier初始化、正则化方法和MSGD的BP网络，以及主函数模块中的绘制R2图、输出MAE、MSE、预测值和真实值之间的相对误差平均百分比、绘制各输入输出的拟合折线图等功能。您可以在自己的机器上运行这些代码，看看是否能够成功实现。