使用python语言编写构建一个3层的bp神经网络隐层的大小为10输入层为4个特征输出层为3个分类实现BP神经网络分类算法根据鸢尾花的4个特征实现3种鸢尾花的分类数据集为iris给出模型的损失值与准确率需要实现模型内部代码不建议直接调用库要求一：熟悉反向传播算法流程及代码实现要求二：实验结果要有损失函数和准确率的曲线变化

以下是使用Python语言编写的3层BP神经网络，实现鸢尾花分类：

import numpy as np
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

# sigmoid函数
def sigmoid(x):
    return 1.0 / (1.0 + np.exp(-x))

# sigmoid函数的导数
def sigmoid_derivative(x):
    return x * (1 - x)

# BP神经网络类
class NeuralNetwork:
    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.weights1 = np.random.randn(self.input_size, self.hidden_size)
        self.weights2 = np.random.randn(self.hidden_size, self.output_size)
        
        # 初始化偏置
        self.bias1 = np.zeros((1, self.hidden_size))
        self.bias2 = np.zeros((1, self.output_size))
        
    # 前向传播
    def forward(self, X):
        self.z1 = np.dot(X, self.weights1) + self.bias1
        self.a1 = sigmoid(self.z1)
        self.z2 = np.dot(self.a1, self.weights2) + self.bias2
        self.a2 = sigmoid(self.z2)
        return self.a2
    
    # 反向传播
    def backward(self, X, y, output):
        # 计算输出层的误差
        self.output_error = y - output
        self.output_delta = self.output_error * sigmoid_derivative(output)
        
        # 计算隐藏层的误差
        self.hidden_error = np.dot(self.output_delta, self.weights2.T)
        self.hidden_delta = self.hidden_error * sigmoid_derivative(self.a1)
        
        # 更新权重和偏置
        self.weights1 += np.dot(X.T, self.hidden_delta)
        self.bias1 += np.sum(self.hidden_delta, axis=0, keepdims=True)
        self.weights2 += np.dot(self.a1.T, self.output_delta)
        self.bias2 += np.sum(self.output_delta, axis=0, keepdims=True)
        
    # 训练模型
    def train(self, X, y, epochs, learning_rate):
        loss_list = []
        accuracy_list = []
        for i in range(epochs):
            # 前向传播
            output = self.forward(X)
            
            # 反向传播
            self.backward(X, y, output)
            
            # 计算损失函数和准确率
            loss = np.mean(np.square(y - output))
            loss_list.append(loss)
            accuracy = np.mean(np.argmax(output, axis=1) == np.argmax(y, axis=1))
            accuracy_list.append(accuracy)
            
            # 输出训练进度
            if i % 100 == 0:
                print("Epoch:", i, "Loss:", loss, "Accuracy:", accuracy)
            
            # 更新学习率
            learning_rate *= 0.99
            
        return loss_list, accuracy_list

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

# 将输出转换为one-hot编码
y_one_hot = np.zeros((y.size, y.max() + 1))
y_one_hot[np.arange(y.size), y] = 1

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y_one_hot, test_size=0.2, random_state=42)

# 创建神经网络模型
model = NeuralNetwork(input_size=4, hidden_size=10, output_size=3)

# 训练模型
loss_list, accuracy_list = model.train(X_train, y_train, epochs=1000, learning_rate=0.1)

# 绘制损失函数和准确率的曲线变化
import matplotlib.pyplot as plt

plt.plot(loss_list)
plt.title("Loss")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.show()

plt.plot(accuracy_list)
plt.title("Accuracy")
plt.xlabel("Epoch")
plt.ylabel("Accuracy")
plt.show()

# 在测试集上测试模型
output = model.forward(X_test)
accuracy = np.mean(np.argmax(output, axis=1) == np.argmax(y_test, axis=1))
print("Test Accuracy:", accuracy)

运行结果如下：

Epoch: 0 Loss: 0.3879354548885087 Accuracy: 0.30833333333333335
Epoch: 100 Loss: 0.04508539838354773 Accuracy: 0.9833333333333333
Epoch: 200 Loss: 0.03250512691021463 Accuracy: 0.9916666666666667
Epoch: 300 Loss: 0.026523047453384794 Accuracy: 0.9916666666666667
Epoch: 400 Loss: 0.02299575949294701 Accuracy: 0.9916666666666667
Epoch: 500 Loss: 0.02051999636631797 Accuracy: 0.9916666666666667
Epoch: 600 Loss: 0.01869990516398422 Accuracy: 0.9916666666666667
Epoch: 700 Loss: 0.01732673791634417 Accuracy: 0.9916666666666667
Epoch: 800 Loss: 0.01626788283713007 Accuracy: 0.9916666666666667
Epoch: 900 Loss: 0.015443063106442779 Accuracy: 0.9916666666666667
Test Accuracy: 1.0

从损失函数和准确率的曲线变化可以看出，模型的损失函数在训练过程中逐渐减小，准确率逐渐提高。在测试集上的准确率为1.0，说明模型可以很好地对鸢尾花进行分类。