numpy实现bp神经网络并保存模型

由于这个问题比较复杂，涉及到很多知识点，以下是一个简单的实现过程，仅供参考。

首先需要导入numpy库。

import numpy as np

定义一个BP神经网络类，包括初始化、前向传播、反向传播和模型保存函数。

class BPNeuralNetwork:
    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(input_size, hidden_size) / np.sqrt(input_size)
        self.b1 = np.zeros((1, hidden_size))
        self.W2 = np.random.randn(hidden_size, output_size) / np.sqrt(hidden_size)
        self.b2 = np.zeros((1, output_size))
    
    def forward(self, X):
        self.z1 = X.dot(self.W1) + self.b1
        self.a1 = np.tanh(self.z1)
        self.z2 = self.a1.dot(self.W2) + self.b2
        self.a2 = self.sigmoid(self.z2)
        return self.a2
    
    def backward(self, X, y, output):
        delta2 = (output - y) * self.sigmoid_prime(self.z2)
        dW2 = self.a1.T.dot(delta2)
        db2 = np.sum(delta2, axis=0, keepdims=True)
        delta1 = delta2.dot(self.W2.T) * self.tanh_prime(self.z1)
        dW1 = X.T.dot(delta1)
        db1 = np.sum(delta1, axis=0)
        return dW1, db1, dW2, db2
    
    def train(self, X, y, epochs, learning_rate):
        for i in range(epochs):
            output = self.forward(X)
            dW1, db1, dW2, db2 = self.backward(X, y, output)
            self.W1 -= learning_rate * dW1
            self.b1 -= learning_rate * db1
            self.W2 -= learning_rate * dW2
            self.b2 -= learning_rate * db2
    
    def predict(self, X):
        return self.forward(X)
    
    def save_model(self, model_name):
        np.savez(model_name, W1=self.W1, b1=self.b1, W2=self.W2, b2=self.b2)
        
    def sigmoid(self, z):
        return 1 / (1 + np.exp(-z))
    
    def sigmoid_prime(self, z):
        return self.sigmoid(z) * (1 - self.sigmoid(z))
    
    def tanh_prime(self, z):
        return 1 - np.tanh(z)**2

其中，初始化函数中使用了随机初始化权重的方法，可以提高模型的效果。前向传播函数中，使用了tanh作为激活函数，输出层使用sigmoid函数。反向传播函数中，分别计算了输出层和隐藏层的误差，并根据误差计算了梯度。训练函数中，使用了梯度下降的方法进行优化，迭代次数为epochs次，学习率为learning_rate。预测函数中，返回前向传播的结果。保存模型函数中，使用了numpy自带的np.savez()函数，将权重和偏置保存为一个.npz文件。

接下来，使用iris数据集进行训练和测试，保存训练好的模型。

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

# 加载数据集
iris = load_iris()
X = iris.data
y = iris.target

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=0)

# 创建BP神经网络模型
nn = BPNeuralNetwork(input_size=4, hidden_size=8, output_size=3)

# 训练模型
nn.train(X_train, y_train, epochs=10000, learning_rate=0.01)

# 保存模型
nn.save_model('iris_nn_model.npz')

# 加载模型
model = np.load('iris_nn_model.npz')
nn.W1 = model['W1']
nn.b1 = model['b1']
nn.W2 = model['W2']
nn.b2 = model['b2']

# 在测试集上进行预测
y_pred = np.argmax(nn.predict(X_test), axis=1)

# 计算准确率
accuracy = np.sum(y_pred == y_test) / len(y_test)
print("Accuracy:", accuracy)

以上代码中，使用了sklearn库中的load_iris()函数加载iris数据集，使用train_test_split()函数将数据集划分为训练集和测试集。创建了一个输入层大小为4，隐藏层大小为8，输出层大小为3的BP神经网络模型，并使用train()函数进行训练。训练完模型后，使用save_model()函数保存模型。加载模型时，使用np.load()函数加载模型文件，然后将权重和偏置赋值给模型。最后，在测试集上进行预测，并计算准确率。

注意，以上代码中使用的训练集和测试集是随机划分的，每次运行结果可能不同。为了保证结果的可重复性，可以设置一个随机种子。